team-anya-cli 0.1.8 → 1.0.1

package/apps/server/dist/loid/session-manager.js

@@ -1,301 +0,0 @@
-import { join } from 'node:path';
-import { getTasksByStatus } from '@team-anya/db';
-import { TaskStatus } from '@team-anya/core';
-import { LoidSession, } from './session.js';
-import { formatMessageContextPrompt, formatFollowUpPrompt, formatDeliveryContextPrompt, formatRecoveryPrompt, } from './context-builder.js';
-// ── LoidSessionManager ──
-export class LoidSessionManager {
-    sessions = new Map();
-    config;
-    deps;
-    logger;
-    /** 崩溃恢复中的话术池（像同事重启电脑一样自然） */
-    static CRASH_RECOVERY_REPLIES = [
-        '抱歉，刚才脑子卡了一下，我重新捋一下',
-        '不好意思，刚才断片了，我重新接上',
-        '刚才出了点状况，我重新来过',
-        '抱歉打断了，我重新整理一下思路',
-        '不好意思，刚才掉线了，马上接上',
-    ];
-    lastCrashRecoveryIndex = -1;
-    /** 崩溃恢复失败 / 启动失败的话术池 */
-    static STARTUP_FAILURE_REPLIES = [
-        '抱歉，我这边遇到了点问题暂时处理不了，稍后我再试试，或者你可以再发一次',
-        '不好意思，出了点技术问题我暂时响应不了，你可以稍后再@我试试',
-        '抱歉，我这边卡住了，短时间内可能没法响应，你可以过一会儿再找我',
-    ];
-    lastStartupFailureIndex = -1;
-    constructor(config, deps) {
-        this.config = config;
-        this.deps = deps;
-        this.logger = config.logger ?? { info: console.log, error: console.error };
-    }
-    /** 从话术池随机取一句，避免连续重复 */
-    pickRandom(pool, lastIndex) {
-        let idx;
-        do {
-            idx = Math.floor(Math.random() * pool.length);
-        } while (idx === lastIndex && pool.length > 1);
-        return { text: pool[idx], index: idx };
-    }
-    pickCrashRecoveryReply() {
-        const { text, index } = this.pickRandom(LoidSessionManager.CRASH_RECOVERY_REPLIES, this.lastCrashRecoveryIndex);
-        this.lastCrashRecoveryIndex = index;
-        return text;
-    }
-    pickStartupFailureReply() {
-        const { text, index } = this.pickRandom(LoidSessionManager.STARTUP_FAILURE_REPLIES, this.lastStartupFailureIndex);
-        this.lastStartupFailureIndex = index;
-        return text;
-    }
-    // ── 公开方法 ──
-    /**
-     * 处理新消息：有活跃 session 就 enqueue，没有就创建
-     */
-    async handleMessage(chatId, ctx) {
-        const key = chatId;
-        const existing = this.sessions.get(key);
-        if (existing) {
-            const state = existing.getState();
-            if (state !== 'disposed') {
-                const prompt = formatFollowUpPrompt(ctx);
-                existing.enqueue({ type: 'message', prompt, enqueuedAt: new Date() });
-                return;
-            }
-            // session 已销毁，删除并新建
-            this.sessions.delete(key);
-        }
-        // 新建 session
-        try {
-            const session = await this.createSession(key);
-            const contextPrompt = formatMessageContextPrompt(ctx);
-            session.enqueue({ type: 'message', prompt: contextPrompt, enqueuedAt: new Date() });
-        }
-        catch (err) {
-            this.logger.error(`[SessionManager] 创建 session 失败 (${key}):`, err);
-            this.sendChatNotification(key, this.pickStartupFailureReply());
-        }
-    }
-    /**
-     * 处理 Yor 交付验收：查找来源 session，活着就复用，否则新建
-     */
-    async handleDelivery(ctx) {
-        const sourceChatId = ctx.sourceChatId;
-        // 尝试复用来源 session
-        if (sourceChatId && this.sessions.has(sourceChatId)) {
-            const session = this.sessions.get(sourceChatId);
-            const state = session.getState();
-            if (state !== 'disposed') {
-                const prompt = formatDeliveryContextPrompt(ctx);
-                session.enqueue({ type: 'delivery', prompt, enqueuedAt: new Date() });
-                return;
-            }
-            this.sessions.delete(sourceChatId);
-        }
-        // 来源 session 已回收，新建独立 session
-        const key = `delivery:${ctx.taskId}`;
-        try {
-            const session = await this.createSession(key);
-            const protocol = this.config.protocols['review'] ?? '';
-            const prompt = [
-                protocol ? protocol + '\n\n---\n\n' : '',
-                formatDeliveryContextPrompt(ctx),
-            ].join('');
-            session.enqueue({ type: 'delivery', prompt, enqueuedAt: new Date() });
-        }
-        catch (err) {
-            this.logger.error(`[SessionManager] 创建 delivery session 失败 (${key}):`, err);
-            // delivery 场景通知来源群
-            if (ctx.sourceChatId) {
-                this.sendChatNotification(ctx.sourceChatId, this.pickStartupFailureReply());
-            }
-        }
-    }
-    /**
-     * 获取当前活跃 session 数量
-     */
-    getSessionCount() {
-        return this.sessions.size;
-    }
-    /**
-     * 获取指定 session 的状态（用于诊断）
-     */
-    getSessionState(key) {
-        return this.sessions.get(key)?.getState() ?? null;
-    }
-    /**
-     * 关闭所有 session，释放资源
-     */
-    async dispose() {
-        const disposePromises = [];
-        for (const [key, session] of this.sessions) {
-            this.logger.info(`[SessionManager] 正在关闭 session: ${key}`);
-            disposePromises.push(session.dispose());
-        }
-        await Promise.all(disposePromises);
-        this.sessions.clear();
-        this.logger.info('[SessionManager] 所有 session 已关闭');
-    }
-    // ── 私有方法 ──
-    /**
-     * 创建新 LoidSession，注册生命周期回调
-     * 如果 broker 槽位满，尝试 LRU 淘汰后重试
-     */
-    async createSession(key) {
-        this.logger.info(`[SessionManager] 创建新 session: ${key}`);
-        const instanceId = `loid:${key}`;
-        const logFile = this.config.logDir
-            ? join(this.config.logDir, `loid-${key.replace(/[/:]/g, '_')}-${Date.now()}.log`)
-            : undefined;
-        const sessionConfig = {
-            broker: this.config.broker,
-            instanceId,
-            backendConfig: this.config.backendConfig,
-            idleTimeoutMs: this.config.idleTimeoutMs,
-            maxTurns: this.config.maxTurnsPerSession,
-            logFile,
-            db: this.deps.db,
-            chatId: key,
-            logger: this.logger,
-        };
-        const session = new LoidSession(sessionConfig, {
-            onCrash: (orphanMessages) => {
-                this.onSessionCrash(key, orphanMessages);
-            },
-            onDisposed: () => {
-                this.logger.info(`[SessionManager] session 自然结束: ${key}`);
-                this.sessions.delete(key);
-            },
-        });
-        try {
-            await session.connect();
-        }
-        catch (err) {
-            // 槽位满时尝试 LRU 淘汰
-            if (err instanceof Error && err.message.includes('实例已满')) {
-                const evicted = await this.evictLRU();
-                if (evicted) {
-                    this.logger.info(`[SessionManager] LRU 淘汰 ${evicted}，重试创建 ${key}`);
-                    await session.connect();
-                }
-                else {
-                    throw err;
-                }
-            }
-            else {
-                throw err;
-            }
-        }
-        this.sessions.set(key, session);
-        return session;
-    }
-    /**
-     * LRU 淘汰：找到最久没活动且处于 IDLE 的 session，dispose 它
-     * 返回被淘汰的 session key，无可淘汰时返回 null
-     */
-    async evictLRU() {
-        let oldestKey = null;
-        let oldestTime = Infinity;
-        for (const [key, session] of this.sessions) {
-            if (session.getState() === 'idle') {
-                const activityTime = session.getLastActivityAt().getTime();
-                if (activityTime < oldestTime) {
-                    oldestTime = activityTime;
-                    oldestKey = key;
-                }
-            }
-        }
-        if (oldestKey) {
-            const session = this.sessions.get(oldestKey);
-            await session.dispose();
-            this.sessions.delete(oldestKey);
-            this.logger.info(`[SessionManager] LRU 淘汰 session: ${oldestKey}`);
-            return oldestKey;
-        }
-        return null;
-    }
-    /**
-     * Session 崩溃恢复：删旧 session，通知用户，新建处理孤儿消息
-     */
-    async onSessionCrash(key, orphanedMessages) {
-        this.logger.error(`[SessionManager] session 崩溃: ${key} (${orphanedMessages.length} 条孤儿消息)`);
-        // 删除旧 session
-        this.sessions.delete(key);
-        // 通知用户：正在恢复
-        const chatId = this.extractChatId(key);
-        if (chatId) {
-            this.sendChatNotification(chatId, this.pickCrashRecoveryReply());
-        }
-        // 从 DB 加载活跃任务状态作为恢复上下文
-        const activeTasks = this.getActiveTasks();
-        const recoveryPrompt = formatRecoveryPrompt(activeTasks);
-        try {
-            const newSession = await this.createSession(key);
-            // 先投递恢复上下文
-            newSession.enqueue({ type: 'recovery', prompt: recoveryPrompt, enqueuedAt: new Date() });
-            // 再投递孤儿消息
-            for (const msg of orphanedMessages) {
-                newSession.enqueue(msg);
-            }
-        }
-        catch (err) {
-            this.logger.error(`[SessionManager] 崩溃恢复失败 (${key}):`, err);
-            // 恢复失败：告知用户
-            if (chatId) {
-                this.sendChatNotification(chatId, this.pickStartupFailureReply());
-            }
-        }
-    }
-    /**
-     * 从 session key 提取 chatId（过滤掉 delivery: 等前缀的内部 key）
-     * 只有来自用户对话的 session 才需要通知
-     */
-    extractChatId(key) {
-        // delivery:ANYA-xxx 等内部 session 不直接通知用户
-        if (key.startsWith('delivery:'))
-            return null;
-        return key;
-    }
-    /**
-     * 向飞书群发送通知（fire-and-forget），同时清除"处理中"表情
-     */
-    sendChatNotification(chatId, text) {
-        if (!this.deps.feishuSender)
-            return;
-        // 清除 typing reaction（通知本身就是反馈）
-        this.deps.feishuSender.clearTypingReaction(chatId).catch(() => { });
-        this.deps.feishuSender.sendText({
-            receiveIdType: 'chat_id',
-            receiveId: chatId,
-            text,
-        }).catch(err => {
-            this.logger.error('[SessionManager] 崩溃通知发送失败:', err);
-        });
-    }
-    /**
-     * 获取活跃任务列表（用于崩溃恢复上下文）
-     */
-    getActiveTasks() {
-        const statuses = [
-            TaskStatus.IN_PROGRESS,
-            TaskStatus.READY,
-            TaskStatus.NEED_CLARIFICATION,
-            TaskStatus.DELIVERING,
-            TaskStatus.BLOCKED,
-        ];
-        const tasks = [];
-        for (const status of statuses) {
-            const statusTasks = getTasksByStatus(this.deps.db, status);
-            for (const t of statusTasks) {
-                tasks.push({
-                    task_id: t.task_id,
-                    title: t.title,
-                    status: t.status,
-                    assignee: t.assignee,
-                });
-            }
-        }
-        return tasks;
-    }
-}
-//# sourceMappingURL=session-manager.js.map

package/apps/server/dist/loid/session.js

@@ -1,271 +0,0 @@
-import { insertCCSession, updateCCSessionEnded } from '@team-anya/db';
-// ── 常量 ──
-const DEFAULT_IDLE_TIMEOUT_MS = 2 * 60 * 60 * 1000; // 2 小时
-const DEFAULT_MAX_TURNS = 50;
-// ── LoidSession ──
-export class LoidSession {
-    state = 'idle';
-    broker;
-    instanceId;
-    config;
-    callbacks;
-    pendingMessages = [];
-    turnCount = 0;
-    maxTurns;
-    idleTimer = null;
-    lastActivityAt = new Date();
-    connected = false;
-    cliSessionId = null;
-    /** Broker 事件监听器引用（用于 dispose 时清理） */
-    boundResultListener = null;
-    boundCrashListener = null;
-    boundExitedListener = null;
-    constructor(config, callbacks) {
-        this.config = config;
-        this.callbacks = callbacks;
-        this.maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
-        this.broker = config.broker;
-        this.instanceId = config.instanceId;
-    }
-    // ── 公开方法 ──
-    /**
-     * 通过 CCBroker 启动 CC 进程并建立连接
-     */
-    async connect() {
-        // 注册 broker 事件监听（过滤当前 instanceId）
-        this.boundResultListener = (id, _role, result) => {
-            if (id === this.instanceId) {
-                this.handleResult(result);
-            }
-        };
-        this.boundCrashListener = (id, _role, _error) => {
-            if (id === this.instanceId) {
-                this.handleCrash();
-            }
-        };
-        this.boundExitedListener = (id) => {
-            if (id === this.instanceId && this.connected) {
-                if (this.state !== 'disposed') {
-                    this.config.logger?.error('[LoidSession] CC 进程异常退出，触发崩溃恢复');
-                    this.handleCrash();
-                }
-            }
-        };
-        this.broker.on('instance.result', this.boundResultListener);
-        this.broker.on('instance.crash', this.boundCrashListener);
-        this.broker.on('instance.exited', this.boundExitedListener);
-        // 监听 CC session ID
-        const sessionIdListener = (id, cliSessionId) => {
-            if (id === this.instanceId && this.config.db) {
-                this.cliSessionId = cliSessionId;
-                insertCCSession(this.config.db, {
-                    session_id: cliSessionId,
-                    role: 'loid',
-                    instance_id: this.instanceId,
-                    chat_id: this.config.chatId,
-                    project_path: this.config.backendConfig.workingDir,
-                });
-                this.config.logger?.info(`[LoidSession] 记录 CC session: ${cliSessionId}`);
-                // 一次性监听，获取后移除
-                this.broker.removeListener('instance.sessionId', sessionIdListener);
-            }
-        };
-        this.broker.on('instance.sessionId', sessionIdListener);
-        await this.broker.spawn({
-            id: this.instanceId,
-            role: 'loid',
-            backendConfig: this.config.backendConfig,
-            logFile: this.config.logFile,
-        });
-        this.connected = true;
-        this.resetIdleTimer();
-    }
-    /**
-     * 投递消息：IDLE 时直接发送，EXECUTING 时缓冲
-     * 返回 false 表示 session 不接受消息（DISPOSED）
-     */
-    enqueue(msg) {
-        if (this.state === 'disposed') {
-            return false;
-        }
-        this.lastActivityAt = new Date();
-        if (this.state === 'idle') {
-            this.state = 'executing';
-            this.clearIdleTimer();
-            try {
-                this.broker.sendPrompt(this.instanceId, msg.prompt);
-            }
-            catch (err) {
-                this.config.logger?.error('[LoidSession] sendPrompt 失败:', err);
-                this.handleCrash();
-            }
-        }
-        else {
-            // EXECUTING → 缓冲
-            this.pendingMessages.push(msg);
-        }
-        return true;
-    }
-    /**
-     * 获取当前状态
-     */
-    getState() {
-        return this.state;
-    }
-    /**
-     * 获取当前轮次数
-     */
-    getTurnCount() {
-        return this.turnCount;
-    }
-    /**
-     * 获取缓冲区消息数
-     */
-    getPendingCount() {
-        return this.pendingMessages.length;
-    }
-    /**
-     * 获取最后活跃时间（供 LRU 淘汰使用）
-     */
-    getLastActivityAt() {
-        return this.lastActivityAt;
-    }
-    /**
-     * 销毁 session，释放资源
-     */
-    async dispose() {
-        if (this.state === 'disposed')
-            return;
-        this.state = 'disposed';
-        this.clearIdleTimer();
-        this.connected = false;
-        // 更新 cc_sessions.ended_at
-        if (this.cliSessionId && this.config.db) {
-            updateCCSessionEnded(this.config.db, this.cliSessionId);
-        }
-        this.removeBrokerListeners();
-        await this.broker.dispose(this.instanceId).catch(() => { });
-    }
-    // ── 私有方法 ──
-    /**
-     * CC 执行完一轮后的 drain loop
-     */
-    handleResult(result) {
-        this.callbacks.onResult?.(result);
-        this.turnCount++;
-        this.lastActivityAt = new Date();
-        if (this.state === 'disposed')
-            return;
-        // drain: 缓冲区有消息 → 合并发送
-        if (this.pendingMessages.length > 0) {
-            const buffered = this.pendingMessages.splice(0);
-            const prompt = this.formatBufferedMessages(buffered);
-            try {
-                this.broker.sendPrompt(this.instanceId, prompt);
-            }
-            catch (err) {
-                this.config.logger?.error('[LoidSession] drain sendPrompt 失败:', err);
-                this.handleCrash();
-            }
-            return;
-        }
-        // 达到硬上限 → 直接 dispose（不生成摘要）
-        if (this.turnCount >= this.maxTurns) {
-            this.config.logger?.info(`[LoidSession] 达到硬上限 (${this.maxTurns} 轮)，销毁 session`);
-            this.disposeAndNotify();
-            return;
-        }
-        // 无待处理消息 → 回 IDLE，启动空闲计时器
-        this.state = 'idle';
-        this.resetIdleTimer();
-    }
-    /**
-     * 崩溃处理：交还未处理消息，标记 disposed
-     */
-    handleCrash() {
-        if (this.state === 'disposed')
-            return;
-        this.state = 'disposed';
-        this.clearIdleTimer();
-        this.connected = false;
-        this.removeBrokerListeners();
-        const orphans = this.pendingMessages.splice(0);
-        this.callbacks.onCrash(orphans);
-    }
-    /**
-     * dispose 并通知回调
-     */
-    async disposeAndNotify() {
-        await this.dispose();
-        this.callbacks.onDisposed();
-    }
-    /**
-     * 重置空闲计时器
-     */
-    resetIdleTimer() {
-        this.clearIdleTimer();
-        const timeout = this.config.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-        this.idleTimer = setTimeout(() => {
-            if (this.state === 'idle') {
-                this.config.logger?.info(`[LoidSession] 空闲超时 (${timeout}ms)，销毁 session`);
-                this.disposeAndNotify();
-            }
-        }, timeout);
-    }
-    /**
-     * 清除空闲计时器
-     */
-    clearIdleTimer() {
-        if (this.idleTimer) {
-            clearTimeout(this.idleTimer);
-            this.idleTimer = null;
-        }
-    }
-    /**
-     * 移除 broker 事件监听器
-     */
-    removeBrokerListeners() {
-        if (this.boundResultListener) {
-            this.broker.removeListener('instance.result', this.boundResultListener);
-            this.boundResultListener = null;
-        }
-        if (this.boundCrashListener) {
-            this.broker.removeListener('instance.crash', this.boundCrashListener);
-            this.boundCrashListener = null;
-        }
-        if (this.boundExitedListener) {
-            this.broker.removeListener('instance.exited', this.boundExitedListener);
-            this.boundExitedListener = null;
-        }
-    }
-    /**
-     * 合并缓冲消息为单个 prompt
-     * 临时内联实现（正式版本由 context-builder 的 formatBufferedMessages 提供）
-     */
-    formatBufferedMessages(messages) {
-        if (messages.length === 1) {
-            return messages[0].prompt;
-        }
-        const lines = [];
-        lines.push(`你在处理上一件事的过程中，该对话又收到了 ${messages.length} 条新消息：`);
-        lines.push('');
-        for (let i = 0; i < messages.length; i++) {
-            const msg = messages[i];
-            const time = msg.enqueuedAt.toLocaleTimeString('zh-CN', {
-                hour: '2-digit',
-                minute: '2-digit',
-                second: '2-digit',
-                hour12: false,
-            });
-            const typeLabel = msg.type === 'delivery' ? ' [交付]'
-                : msg.type === 'recovery' ? ' [恢复]'
-                    : '';
-            lines.push(`--- 消息 ${i + 1} (${time}${typeLabel}) ---`);
-            lines.push(msg.prompt);
-            lines.push('');
-        }
-        lines.push('请综合这些新消息，决定下一步行动。');
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=session.js.map