evolcore 0.0.31 → 0.0.33

package/dist/core/thread/thread-operation.js

@@ -0,0 +1,258 @@
+import { normalizeThreadPeer } from './thread-service.js';
+export function executeThreadOperation(request, threadService, sendSystemMsg) {
+    return _executeThreadOperation(request, threadService, sendSystemMsg);
+}
+async function _executeThreadOperation(request, threadService, sendSystemMsg) {
+    const op = String(request.op);
+    const selfAid = typeof request.selfAid === 'string' ? request.selfAid : '';
+    if (!selfAid)
+        return { ok: false, code: 'MISSING_SELF_AID', error: 'selfAid is required' };
+    // 入口归一：调用方可能传入裸 ID 或带渠道前缀的写法，统一成索引里存储的形态。
+    // 归一失败（解析不出）时保留原值，由下游按"无此对端"处理，不改变 arg 缺失的语义。
+    request = { ...request, peer: normalizeThreadPeer(request.peer) ?? request.peer };
+    try {
+        switch (op) {
+            case 'list': {
+                const result = threadService.listThreads({
+                    selfAid,
+                    peer: request.peer,
+                    status: request.status,
+                    label: request.label ?? undefined,
+                    unlabeled: request.unlabeled,
+                    sort: request.sort,
+                    page: request.page,
+                    limit: request.limit,
+                });
+                const threads = result.threads.map(t => ({
+                    ...t,
+                    running: false,
+                    peerName: t.peerName ?? t.peer,
+                }));
+                return { ok: true, result: { ...result, threads } };
+            }
+            case 'list-peers': {
+                const peers = threadService.listPeers(selfAid);
+                return { ok: true, result: { peers } };
+            }
+            case 'show': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer is required' };
+                // peer-only ref (no threadId) → show main session
+                if (!threadId) {
+                    const result = await threadService.showMainSession(selfAid, peer);
+                    if (!result)
+                        return { ok: false, code: 'NOT_FOUND', error: `与 ${peer} 无活跃主会话` };
+                    return { ok: true, result };
+                }
+                const result = await threadService.showThread({ selfAid, peer, threadId });
+                // 索引健康检查：检测 session 文件是否存在
+                const indexWarning = result._indexWarning;
+                const resp = { ok: true, result };
+                if (indexWarning)
+                    resp.indexWarning = indexWarning;
+                return resp;
+            }
+            case 'check-index': {
+                const result = threadService.checkIndex(selfAid);
+                let warning;
+                if (result.missing > 0 && result.stale > 0) {
+                    warning = `索引异常：${result.missing} 条 session 文件缺失（数据问题），${result.stale} 条属性与文件不一致（写盘时序）`;
+                }
+                else if (result.missing > 0) {
+                    warning = `索引异常：${result.missing} 条 session 文件缺失，rebuild-index 后相关话题的 rename/label/status 改动将回退`;
+                }
+                else if (result.stale > 0) {
+                    warning = `索引轻微不一致：${result.stale} 条话题属性（name/label/status）与 session 文件最后一行不同步，rebuild-index 可修复`;
+                }
+                return { ok: true, result, indexWarning: warning };
+            }
+            case 'history': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if (!peer && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                // threadId 可选：不传时读主会话（threadId=null）消息
+                if (!peer)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer is required' };
+                const result = await threadService.historyThread({
+                    selfAid,
+                    peer,
+                    threadId,
+                    limit: request.limit,
+                    before: request.before,
+                    after: request.after,
+                    direction: request.direction,
+                });
+                return { ok: true, result };
+            }
+            case 'create': {
+                if (!request.peer || !request.name)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and name required' };
+                const result = await threadService.createThread({
+                    selfAid,
+                    peer: request.peer,
+                    peerKind: request.peerKind ?? 'private',
+                    name: request.name,
+                    label: request.label ?? undefined,
+                    topicStatus: request.topicStatus,
+                });
+                if (sendSystemMsg) {
+                    try {
+                        await sendSystemMsg({
+                            from: selfAid,
+                            to: request.peer,
+                            threadId: result.threadId,
+                            topicName: result.name,
+                            peerKind: request.peerKind ?? 'private',
+                        });
+                    }
+                    catch {
+                        // 系统消息发送失败不影响本地创建
+                    }
+                }
+                return { ok: true, result };
+            }
+            case 'rename': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId || !request.name)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer, threadId and name required' };
+                const result = await threadService.renameThread({ selfAid, peer, threadId, name: request.name });
+                return { ok: true, result };
+            }
+            case 'label': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and threadId required' };
+                await threadService.labelThread({ selfAid, peer, threadId, label: request.label ?? null });
+                return { ok: true };
+            }
+            case 'status': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId || !request.topicStatus)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer, threadId and topicStatus required' };
+                await threadService.statusThread({ selfAid, peer, threadId, topicStatus: request.topicStatus });
+                return { ok: true };
+            }
+            case 'rebuild-index': {
+                const dryRun = request.dryRun === true;
+                const result = await threadService.rebuildIndex(selfAid, dryRun);
+                if (dryRun) {
+                    const { rebuilt } = result;
+                    const check = threadService.checkIndex(selfAid);
+                    return { ok: true, result: { rebuilt, missing: check.missing, missingIds: check.missingIds, dryRun: true } };
+                }
+                return { ok: true, result };
+            }
+            case 'delete': {
+                let peer = request.peer;
+                let threadId = request.threadId;
+                if ((!peer || !threadId) && request.sessionId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    if (resolved) {
+                        peer = resolved.peer;
+                        threadId = resolved.threadId;
+                    }
+                }
+                if (!peer || !threadId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'peer and threadId required' };
+                await threadService.deleteThread(selfAid, peer, threadId);
+                return { ok: true };
+            }
+            case 'summary-show': {
+                if (!request.sessionId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId required' };
+                const result = threadService.showSummary(selfAid, request.sessionId);
+                return { ok: true, result: result ?? null };
+            }
+            case 'summary-set': {
+                if (!request.sessionId || !request.content)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId and content required' };
+                // 覆盖游标由 service 自动记录（写入时刻话题最后一条消息的 ts），调用方不用传。
+                const result = threadService.setSummary(selfAid, request.sessionId, request.content, request.ifRev);
+                // 顺带改名：总结时往往正好把话题主题想清楚了，一次命令写完更省事。
+                // 调用方（CLI / slash）保证 name 一定存在；`-` 表示"保持原标题不改"。
+                // 主会话没有话题名可改（threadId 为空），忽略该参数而不是报错。
+                const rawName = typeof request.name === 'string' ? request.name.trim() : '';
+                let name = rawName && rawName !== '-' ? rawName : undefined;
+                let threadId = request.threadId;
+                if (name && !threadId) {
+                    const resolved = threadService.resolveCurrentThread(selfAid, request.sessionId);
+                    threadId = resolved?.threadId;
+                }
+                let peer = request.peer;
+                if (name && threadId && !peer) {
+                    peer = threadService.readThreadIndex(selfAid).threads.find(t => t.threadId === threadId)?.peer;
+                }
+                if (name && threadId && peer) {
+                    try {
+                        const renamed = await threadService.renameThread({ selfAid, peer, threadId, name });
+                        return { ok: true, result: { ...result, renamedTo: renamed.name, renamedChanged: renamed.changed } };
+                    }
+                    catch (e) {
+                        // 摘要已写入，改名失败不回滚——如实返回，让调用方知道只有改名这步没成
+                        return {
+                            ok: true,
+                            result: { ...result, renameError: e?.message ?? String(e) },
+                        };
+                    }
+                }
+                return { ok: true, result };
+            }
+            case 'summary-log': {
+                if (!request.sessionId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId required' };
+                const result = threadService.logSummary(selfAid, request.sessionId);
+                return { ok: true, result };
+            }
+            case 'summary-clear': {
+                if (!request.sessionId)
+                    return { ok: false, code: 'MISSING_ARGS', error: 'sessionId required' };
+                threadService.clearSummary(selfAid, request.sessionId);
+                return { ok: true };
+            }
+            default:
+                return { ok: false, code: 'UNKNOWN_OP', error: `Unknown op: ${op}` };
+        }
+    }
+    catch (error) {
+        return { ok: false, code: error.code ?? 'ERROR', error: error.message ?? String(error) };
+    }
+}

package/dist/core/thread/thread-route.js

@@ -0,0 +1,33 @@
+import { sameGroupAid } from '../../aun/group/identity.js';
+import { ThreadService } from './thread-service.js';
+/**
+ * 解析 `--thread` 跨话题发送的目标话题。
+ *
+ * 话题必须存在于发送方本端索引、属于 AUN 渠道、peerKind 与发送 scope 一致；
+ * 给出 target 时还必须与话题 peer 相同（群按群 AID 规范化比较）。
+ * 返回 undefined 表示该 thread 不能作为跨话题路由依据。
+ */
+export function resolveThreadRouteTarget(selfAid, threadId, scope, target) {
+    if (!selfAid || !threadId)
+        return undefined;
+    let entry;
+    try {
+        entry = ThreadService.findThreadById(selfAid.replace(/^@/, ''), threadId);
+    }
+    catch {
+        return undefined;
+    }
+    if (!entry)
+        return undefined;
+    if ((entry.channelType ?? 'aun') !== 'aun')
+        return undefined;
+    if (entry.peerKind !== (scope === 'group' ? 'group' : 'private'))
+        return undefined;
+    if (target === undefined)
+        return entry;
+    const normalizedTarget = target.replace(/^@/, '');
+    const matches = scope === 'group'
+        ? sameGroupAid(entry.peer, normalizedTarget)
+        : entry.peer === normalizedTarget;
+    return matches ? entry : undefined;
+}