team-anya 0.1.0

package/apps/server/dist/loid/mcp-server.js

@@ -0,0 +1,104 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { Server } from '@modelcontextprotocol/sdk/server';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { createToolRouter } from '@team-anya/mcp-tools';
+// ── MCP Server 创建（薄路由层） ──
+function createMcpServer(deps) {
+    const routerDeps = {
+        db: deps.db,
+        workspacePath: deps.workspacePath,
+        channelRegistry: deps.channelRegistry,
+        logger: deps.logger,
+        onMessageSent: deps.onMessageSent,
+        yorOrchestrator: deps.yorOrchestrator,
+        getProjectConfig: deps.getProjectConfig,
+    };
+    const router = createToolRouter('loid', routerDeps);
+    const server = new Server({ name: 'loid-mcp', version: '3.0.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = router.tools.map(def => ({
+            name: def.name,
+            description: def.description,
+            inputSchema: zodToJsonSchema(def.inputSchema),
+        }));
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        deps.onToolCall?.(name);
+        return router.handleToolCall(name, args ?? {});
+    });
+    return server;
+}
+/**
+ * 启动 Loid 指挥型 MCP server（薄路由层）
+ *
+ * 所有工具实现来自 @team-anya/mcp-tools，
+ * 这里只负责 HTTP 传输和 session 管理。
+ */
+export async function startLoidMcpServer(deps) {
+    const sessions = new Map();
+    const httpServer = createServer(async (req, res) => {
+        const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        if (url.pathname !== '/mcp') {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        const sessionId = req.headers['mcp-session-id'];
+        if (sessionId && sessions.has(sessionId)) {
+            const { transport } = sessions.get(sessionId);
+            await transport.handleRequest(req, res);
+            return;
+        }
+        if (req.method === 'POST') {
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+            });
+            const server = createMcpServer(deps);
+            transport.onclose = () => {
+                if (transport.sessionId) {
+                    sessions.delete(transport.sessionId);
+                }
+                // 不在这里调用 server.close()，避免与 close() 函数形成循环调用导致栈溢出
+            };
+            await server.connect(transport);
+            await transport.handleRequest(req, res);
+            if (transport.sessionId) {
+                sessions.set(transport.sessionId, { server, transport });
+            }
+            return;
+        }
+        res.writeHead(400);
+        res.end('Bad Request: No valid session');
+    });
+    await new Promise((resolve) => {
+        httpServer.listen(0, '127.0.0.1', resolve);
+    });
+    const addr = httpServer.address();
+    const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
+    const serverUrl = `http://127.0.0.1:${port}/mcp`;
+    return {
+        port,
+        url: serverUrl,
+        close: async () => {
+            for (const { server, transport } of sessions.values()) {
+                await transport.close();
+                await server.close();
+            }
+            sessions.clear();
+            await new Promise((resolve, reject) => {
+                httpServer.close((err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=mcp-server.js.map

package/apps/server/dist/loid/memory-settler.js

@@ -0,0 +1,189 @@
+// ── MemorySettler ──
+/**
+ * 记忆沉淀器
+ *
+ * 任务完成（DONE）后自动触发，分析 execution-log.jsonl 和 result.md，
+ * 将经过验证的结论写入长期记忆。
+ *
+ * 沉淀规则：
+ * - self_heal 且 result=fixed → pitfalls.md
+ * - decision 事件 → decisions.md
+ * - collaborator_discovery → people/{ref}.md
+ * - result.md 中的"经验教训"section → pitfalls.md
+ */
+export class MemorySettler {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async settle(taskId, taskDir) {
+        const result = {
+            pitfalls: [],
+            decisions: [],
+            collaborators: [],
+            totalSettled: 0,
+            errors: [],
+        };
+        // 1. 读取 execution-log.jsonl
+        const logEntries = await this.readExecutionLog(taskDir);
+        // 2. 读取 result.md
+        const resultMd = await this.deps.readFile(`${taskDir}/result.md`);
+        // 3. 提取 pitfalls（自愈记录，仅 result=fixed）
+        const pitfalls = this.extractPitfalls(logEntries);
+        // 4. 从 result.md 提取额外经验教训
+        const lessonsFromResult = this.extractLessonsFromResult(resultMd);
+        for (const lesson of lessonsFromResult) {
+            if (!pitfalls.includes(lesson)) {
+                pitfalls.push(lesson);
+            }
+        }
+        // 5. 提取 decisions
+        const decisions = this.extractDecisions(logEntries);
+        // 6. 提取 collaborator discoveries
+        const collaborators = this.extractCollaborators(logEntries);
+        // 7. 写入记忆（使用新版 memoryRemember）
+        for (const pitfall of pitfalls) {
+            await this.safeRemember(result, {
+                category: 'project',
+                target: this.deps.projectId,
+                sub_type: 'pitfall',
+                content: pitfall,
+                source: taskId,
+                importance: 0.7,
+            });
+        }
+        for (const decision of decisions) {
+            await this.safeRemember(result, {
+                category: 'project',
+                target: this.deps.projectId,
+                sub_type: 'decision',
+                content: decision,
+                source: taskId,
+                importance: 0.6,
+            });
+        }
+        for (const collab of collaborators) {
+            await this.safeRemember(result, {
+                category: 'people',
+                target: collab.ref,
+                content: collab.detail,
+                source: taskId,
+                importance: 0.5,
+            });
+        }
+        result.pitfalls = pitfalls;
+        result.decisions = decisions;
+        result.collaborators = collaborators;
+        result.totalSettled = pitfalls.length + decisions.length + collaborators.length;
+        // 8. 审计记录
+        try {
+            await this.deps.auditAppend({
+                event_type: 'memory_settled',
+                actor: 'loid',
+                task_id: taskId,
+                summary: `沉淀 ${result.totalSettled} 条记忆 (${pitfalls.length} pitfalls, ${decisions.length} decisions, ${collaborators.length} collaborators)`,
+                detail: {
+                    pitfalls: pitfalls.length,
+                    decisions: decisions.length,
+                    collaborators: collaborators.length,
+                },
+            });
+        }
+        catch {
+            result.errors.push('审计记录写入失败');
+        }
+        return result;
+    }
+    // ── 内部方法 ──
+    async readExecutionLog(taskDir) {
+        const raw = await this.deps.readFile(`${taskDir}/execution-log.jsonl`);
+        if (!raw)
+            return [];
+        const entries = [];
+        for (const line of raw.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                // 解析失败的行跳过
+            }
+        }
+        return entries;
+    }
+    extractPitfalls(entries) {
+        const seen = new Set();
+        const pitfalls = [];
+        for (const entry of entries) {
+            if (entry.event !== 'self_heal')
+                continue;
+            if (entry.result !== 'fixed')
+                continue;
+            if (!entry.detail)
+                continue;
+            const key = entry.detail;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            pitfalls.push(entry.detail);
+        }
+        return pitfalls;
+    }
+    extractLessonsFromResult(resultMd) {
+        if (!resultMd)
+            return [];
+        const lessons = [];
+        // 查找 "## 经验教训" section
+        const sectionPattern = /##\s*经验教训\s*\n([\s\S]*?)(?=\n##\s|\n$|$)/;
+        const match = sectionPattern.exec(resultMd);
+        if (!match)
+            return [];
+        const sectionContent = match[1];
+        // 解析列表项
+        const listPattern = /^[-*]\s+(.+)$/gm;
+        let listMatch;
+        while ((listMatch = listPattern.exec(sectionContent)) !== null) {
+            const lesson = listMatch[1].trim();
+            if (lesson) {
+                lessons.push(lesson);
+            }
+        }
+        return lessons;
+    }
+    extractDecisions(entries) {
+        const decisions = [];
+        for (const entry of entries) {
+            if (entry.event !== 'decision')
+                continue;
+            if (!entry.detail)
+                continue;
+            decisions.push(entry.detail);
+        }
+        return decisions;
+    }
+    extractCollaborators(entries) {
+        const collaborators = [];
+        for (const entry of entries) {
+            if (entry.event !== 'collaborator_discovery')
+                continue;
+            if (!entry.ref || !entry.detail)
+                continue;
+            collaborators.push({
+                ref: entry.ref,
+                detail: entry.detail,
+            });
+        }
+        return collaborators;
+    }
+    async safeRemember(result, input) {
+        try {
+            await this.deps.memoryRemember(input);
+        }
+        catch (e) {
+            result.errors.push(`写入记忆 [${input.category}/${input.target ?? ''}] 失败: ${e.message}`);
+        }
+    }
+}
+//# sourceMappingURL=memory-settler.js.map

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

@@ -0,0 +1,148 @@
+/**
+ * @deprecated 此模块已废弃，核心流程改为 Loid 自主判断。
+ * 保留此文件仅为兼容 HTTP API，新代码请勿使用。
+ */
+import { randomUUID } from 'node:crypto';
+import { createOpportunity, createTask, getOpportunity, getAllOpportunities, getOpportunitiesByStatus, updateOpportunity, getTodayMaxSequence, } from '@team-anya/db';
+import { TaskStatus, IntentLevel, generateTaskId } from '@team-anya/core';
+// ── 关键词列表（复用 intent-classifier 的关键词） ──
+const RISK_WORDS = [
+    '故障', '报警', '错误', '崩溃', '超时', '500', 'oom', 'panic',
+    '宕机', '挂了', '异常', '告警', '失败', 'error', 'crash', 'timeout',
+    'fatal', 'outage', 'down',
+];
+const TASK_VERBS = [
+    '修复', '优化', '排查', '添加', '实现', '删除', '重构', '升级',
+    'fix', 'add', 'implement', 'delete', 'remove', 'refactor', 'upgrade',
+    'optimize', 'debug', 'resolve', 'migrate',
+];
+const IMPACT_WORDS = [
+    '用户', '线上', '生产', '核心', '关键', '影响', '所有', '全部',
+    'production', 'critical', 'users', 'all', 'major',
+];
+// ── OpportunityManager ──
+export class OpportunityManager {
+    db;
+    workspacePath;
+    logger;
+    constructor(deps) {
+        this.db = deps.db;
+        this.workspacePath = deps.workspacePath;
+        this.logger = deps.logger ?? { info: console.log, error: console.error };
+    }
+    /**
+     * 从意图分级结果创建机会
+     * 仅处理 L2_OPPORTUNITY 级别的消息
+     */
+    createFromIntent(input) {
+        if (input.intentLevel !== IntentLevel.L2_OPPORTUNITY) {
+            return null;
+        }
+        const scores = this.scoreOpportunity(input.content);
+        const id = `opp-${randomUUID().slice(0, 8)}`;
+        const opp = createOpportunity(this.db, {
+            id,
+            summary: input.content,
+            status: 'detected',
+            source_ref: input.sourceRef ?? null,
+            score_impact: scores.impact,
+            score_urgency: scores.urgency,
+            score_feasibility: scores.feasibility,
+            score_permission: scores.permission,
+            total_score: scores.total,
+        });
+        this.logger.info(`机会创建: ${id} (score=${scores.total.toFixed(2)})`);
+        return opp;
+    }
+    /**
+     * 4 维评分
+     * - impact: 影响范围（是否涉及用户/线上/核心功能）
+     * - urgency: 紧急程度（是否有风险词/故障词）
+     * - feasibility: 可行性（是否有明确的任务动词）
+     * - permission: 权限适配性（Anya 是否能处理，默认中等）
+     */
+    scoreOpportunity(content) {
+        const lower = content.toLowerCase();
+        // impact: 影响范围
+        const impactHits = IMPACT_WORDS.filter(w => lower.includes(w.toLowerCase())).length;
+        const impact = Math.min(1, 0.3 + impactHits * 0.15);
+        // urgency: 紧急程度
+        const urgencyHits = RISK_WORDS.filter(w => lower.includes(w.toLowerCase())).length;
+        const urgency = Math.min(1, 0.1 + urgencyHits * 0.25);
+        // feasibility: 可行性
+        const feasibilityHits = TASK_VERBS.filter(w => lower.includes(w.toLowerCase())).length;
+        const feasibility = Math.min(1, 0.3 + feasibilityHits * 0.2);
+        // permission: 默认中等
+        const permission = 0.5;
+        // total: 加权平均
+        const total = impact * 0.3 + urgency * 0.3 + feasibility * 0.25 + permission * 0.15;
+        return { impact, urgency, feasibility, permission, total };
+    }
+    /**
+     * 认领机会：转为 confirmed，创建关联 task
+     */
+    confirm(opportunityId) {
+        const opp = getOpportunity(this.db, opportunityId);
+        if (!opp) {
+            throw new Error(`机会 ${opportunityId} 不存在`);
+        }
+        if (opp.status !== 'detected') {
+            throw new Error(`只有 detected 状态的机会可以认领，当前状态: ${opp.status}`);
+        }
+        // 创建关联任务
+        const seq = getTodayMaxSequence(this.db) + 1;
+        const taskId = generateTaskId(seq);
+        const task = createTask(this.db, {
+            task_id: taskId,
+            title: opp.summary,
+            status: TaskStatus.NEW,
+            source_type: 'opportunity',
+            source_ref: opportunityId,
+        });
+        // 更新 opportunity
+        const updated = updateOpportunity(this.db, opportunityId, {
+            status: 'confirmed',
+            converted_task_id: taskId,
+            claimed_at: new Date().toISOString(),
+        });
+        this.logger.info(`机会认领: ${opportunityId} → task ${taskId}`);
+        return { opportunity: updated, task };
+    }
+    /**
+     * 拒绝机会
+     */
+    reject(opportunityId, _reason) {
+        const opp = getOpportunity(this.db, opportunityId);
+        if (!opp) {
+            throw new Error(`机会 ${opportunityId} 不存在`);
+        }
+        const updated = updateOpportunity(this.db, opportunityId, {
+            status: 'rejected',
+        });
+        this.logger.info(`机会拒绝: ${opportunityId}`);
+        return updated;
+    }
+    /**
+     * 查询机会列表（支持 status 和 min_score 过滤）
+     */
+    getOpportunities(filter) {
+        let results;
+        if (filter.status) {
+            results = getOpportunitiesByStatus(this.db, filter.status);
+        }
+        else {
+            results = getAllOpportunities(this.db);
+        }
+        if (filter.min_score !== undefined) {
+            results = results.filter(o => (o.total_score ?? 0) >= filter.min_score);
+        }
+        return results;
+    }
+    /**
+     * 获取单个机会
+     */
+    getOpportunity(opportunityId) {
+        return getOpportunity(this.db, opportunityId);
+    }
+}
+//# sourceMappingURL=opportunity-manager.js.map

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

@@ -0,0 +1,186 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+/**
+ * ProcessManager: 纯进程管理器
+ *
+ * 只负责 Yor 进程的生命周期管理：
+ * - spawn / kill / 监听退出
+ * - 槽位管理（并发控制）
+ * - 退出时通过 EventEmitter 发送事件通知
+ *
+ * 不包含任何业务逻辑（排序、恢复、工作区准备、brief 组装、DB 操作等）。
+ */
+export class ProcessManager extends EventEmitter {
+    slots;
+    maxConcurrency;
+    yorEntry;
+    logger;
+    spawnFn;
+    shuttingDown = false;
+    constructor(config, spawnFn) {
+        super();
+        this.maxConcurrency = config.maxConcurrency;
+        this.yorEntry = config.yorEntry;
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+        this.spawnFn = spawnFn ?? spawn;
+        this.slots = Array.from({ length: config.maxConcurrency }, (_, i) => ({
+            slotId: `slot-${i}`,
+            busy: false,
+            taskId: null,
+            process: null,
+            pid: null,
+            startedAt: null,
+        }));
+    }
+    /**
+     * 启动一个 Yor 子进程
+     * 调用方负责工作区准备和 brief 组装，ProcessManager 只负责 spawn。
+     */
+    async spawn(params) {
+        if (this.shuttingDown) {
+            throw new Error('ProcessManager 正在关闭，无法 spawn 新进程');
+        }
+        const slot = this.findFreeSlot();
+        if (!slot) {
+            throw new Error(`无空闲槽位，当前并发上限 ${this.maxConcurrency}`);
+        }
+        const { taskId, workingDir, briefPath, env } = params;
+        const child = this.spawnFn('npx', [
+            'tsx', this.yorEntry,
+            '--task', taskId,
+            '--workspace', workingDir,
+            '--brief', briefPath,
+        ], {
+            cwd: workingDir,
+            env: { ...process.env, ...env },
+            stdio: 'pipe',
+        });
+        const pid = child.pid ?? 0;
+        slot.busy = true;
+        slot.taskId = taskId;
+        slot.process = child;
+        slot.pid = pid;
+        slot.startedAt = new Date().toISOString();
+        // stdout/stderr 日志转发
+        child.stdout?.on('data', (data) => {
+            const lines = data.toString().trimEnd();
+            if (lines) {
+                this.logger.info(`[Yor:${taskId}] ${lines}`);
+            }
+        });
+        let stderrBuf = '';
+        child.stderr?.on('data', (data) => {
+            const chunk = data.toString();
+            stderrBuf += chunk;
+            const lines = chunk.trimEnd();
+            if (lines) {
+                this.logger.error(`[Yor:${taskId}:stderr] ${lines}`);
+            }
+        });
+        child.on('exit', (code) => {
+            if (code !== 0 && stderrBuf.trim()) {
+                this.logger.error(`[ProcessManager] stderr (${taskId}): ${stderrBuf.trim().slice(0, 500)}`);
+            }
+            this.handleExit(slot, code);
+        });
+        child.on('error', (err) => {
+            this.logger.error(`[ProcessManager] 进程异常 (${taskId}):`, err);
+            this.handleExit(slot, 1);
+        });
+        this.logger.info(`[ProcessManager] 启动 ${taskId} | ${slot.slotId} pid=${pid}`);
+        return { slotId: slot.slotId, pid };
+    }
+    /**
+     * 终止指定槽位的 Yor 进程
+     */
+    async kill(slotId) {
+        const slot = this.slots.find(s => s.slotId === slotId);
+        if (!slot || !slot.busy || !slot.process) {
+            return { success: false };
+        }
+        try {
+            slot.process.kill('SIGTERM');
+            return { success: true };
+        }
+        catch (err) {
+            this.logger.error(`[ProcessManager] kill 失败 (${slotId}):`, err);
+            return { success: false };
+        }
+    }
+    /**
+     * 返回所有槽位的状态
+     */
+    status() {
+        return this.slots.map(s => ({
+            slotId: s.slotId,
+            taskId: s.taskId,
+            pid: s.pid,
+            startedAt: s.startedAt,
+            status: s.busy ? 'busy' : 'idle',
+        }));
+    }
+    /**
+     * 优雅关闭：终止所有运行中的进程
+     */
+    async shutdown(timeoutMs = 30_000) {
+        this.shuttingDown = true;
+        const busySlots = this.slots.filter(s => s.busy);
+        if (busySlots.length === 0) {
+            return { unfinished: [] };
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                const unfinished = [];
+                for (const slot of this.slots) {
+                    if (slot.busy && slot.process) {
+                        slot.process.kill('SIGTERM');
+                        if (slot.taskId) {
+                            unfinished.push(slot.taskId);
+                        }
+                    }
+                }
+                resolve({ unfinished });
+            }, timeoutMs);
+            this.shutdownResolve = () => {
+                clearTimeout(timer);
+                resolve({ unfinished: [] });
+            };
+        });
+    }
+    shutdownResolve = null;
+    findFreeSlot() {
+        for (const slot of this.slots) {
+            if (!slot.busy) {
+                return slot;
+            }
+        }
+        return null;
+    }
+    handleExit(slot, code) {
+        const taskId = slot.taskId;
+        const slotId = slot.slotId;
+        if (taskId) {
+            const label = code === 0 ? '正常退出' : `异常退出 code=${code}`;
+            this.logger.info(`[ProcessManager] 结束 ${taskId} | ${label}`);
+        }
+        // 释放槽位
+        slot.busy = false;
+        slot.taskId = null;
+        slot.process = null;
+        slot.pid = null;
+        slot.startedAt = null;
+        // 发送退出事件（业务处理交给监听方）
+        if (taskId) {
+            this.emit('yor.exited', { slotId, taskId, exitCode: code });
+        }
+        // 检查 shutdown 等待
+        if (this.shuttingDown && this.shutdownResolve) {
+            const stillBusy = this.slots.some(s => s.busy);
+            if (!stillBusy) {
+                this.shutdownResolve();
+                this.shutdownResolve = null;
+            }
+        }
+    }
+}
+//# sourceMappingURL=process-manager.js.map