team-anya-cli 0.1.0

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

@@ -0,0 +1,162 @@
+import { getTask, updateTask, addClarification, getClarifications, answerClarification } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+// ── 问题模板 ──
+const QUESTION_TEMPLATES = {
+    objective: [
+        '这个任务的具体目标是什么？希望达到什么效果？',
+    ],
+    acceptance_criteria: [
+        '这个任务的验收标准是什么？怎样算完成？',
+    ],
+    context: [
+        '能否提供更多背景信息？比如触发场景、影响范围、相关日志等？',
+    ],
+    scope: [
+        '这个任务涉及哪个项目/仓库？影响范围有多大？',
+    ],
+};
+// 精确型 sender 只问关键项（objective 和 acceptance_criteria 优先）
+const CRITICAL_FIELDS = ['objective', 'acceptance_criteria'];
+// ── Clarifier ──
+export class Clarifier {
+    db;
+    getProfileStyle;
+    constructor(deps) {
+        this.db = deps.db;
+        this.getProfileStyle = deps.getProfileStyle;
+    }
+    /**
+     * 检查任务需求的完整性（四要素：objective, acceptance_criteria, context, scope）
+     */
+    checkCompleteness(taskData) {
+        const missing = [];
+        if (!taskData.objective || taskData.objective.trim() === '') {
+            missing.push('objective');
+        }
+        if (!taskData.acceptance_criteria || taskData.acceptance_criteria.trim() === '') {
+            missing.push('acceptance_criteria');
+        }
+        else {
+            // 检查 JSON 数组是否为空
+            try {
+                const parsed = JSON.parse(taskData.acceptance_criteria);
+                if (Array.isArray(parsed) && parsed.length === 0) {
+                    missing.push('acceptance_criteria');
+                }
+            }
+            catch {
+                // 非 JSON 格式，视为有值
+            }
+        }
+        if (!taskData.context || taskData.context.trim() === '') {
+            missing.push('context');
+        }
+        if (!taskData.project_id || taskData.project_id.trim() === '') {
+            missing.push('scope');
+        }
+        return {
+            isComplete: missing.length === 0,
+            missing,
+        };
+    }
+    /**
+     * 根据缺失项生成澄清问题
+     * @param missing 缺失的要素名
+     * @param style sender 的沟通风格（verbose=全问, precise=只问关键项）
+     */
+    generateQuestions(missing, style = 'verbose') {
+        if (missing.length === 0)
+            return [];
+        const fieldsToAsk = style === 'precise'
+            ? missing.filter(m => CRITICAL_FIELDS.includes(m))
+            : missing;
+        // 精确型如果没有关键项缺失，仍至少问第一个缺失项
+        const effectiveFields = fieldsToAsk.length > 0 ? fieldsToAsk : [missing[0]];
+        const questions = [];
+        for (const field of effectiveFields) {
+            const templates = QUESTION_TEMPLATES[field];
+            if (templates) {
+                questions.push(...templates);
+            }
+        }
+        return questions;
+    }
+    /**
+     * 对任务进行需求澄清
+     * - 完整 → 直接转为 READY
+     * - 不完整 → 转为 NEED_CLARIFICATION，生成问题并写入 DB
+     */
+    async clarifyTask(taskId, senderId) {
+        const task = getTask(this.db, taskId);
+        if (!task) {
+            throw new Error(`任务不存在: ${taskId}`);
+        }
+        if (task.status !== TaskStatus.NEW) {
+            throw new Error(`任务状态为 ${task.status}，只有 NEW 状态才能进行澄清`);
+        }
+        const check = this.checkCompleteness({
+            objective: task.objective,
+            acceptance_criteria: task.acceptance_criteria,
+            context: task.context,
+            project_id: task.project_id,
+        });
+        if (check.isComplete) {
+            // 直接转为 READY
+            updateTask(this.db, taskId, { status: TaskStatus.READY });
+            return {
+                needsClarification: false,
+                questions: [],
+                missing: [],
+            };
+        }
+        // 获取 sender 的沟通风格
+        let style = 'verbose';
+        if (senderId && this.getProfileStyle) {
+            try {
+                style = await this.getProfileStyle(senderId);
+            }
+            catch {
+                // 降级为 verbose
+                style = 'verbose';
+            }
+        }
+        const questions = this.generateQuestions(check.missing, style);
+        // 转为 NEED_CLARIFICATION
+        updateTask(this.db, taskId, { status: TaskStatus.NEED_CLARIFICATION });
+        // 将问题写入 clarifications 表
+        for (const question of questions) {
+            addClarification(this.db, {
+                task_id: taskId,
+                question,
+                asked_by: 'loid',
+            });
+        }
+        return {
+            needsClarification: true,
+            questions,
+            missing: check.missing,
+        };
+    }
+    /**
+     * 处理澄清回答
+     * - 更新 clarification 记录
+     * - 如果所有问题都已回答，将任务转为 READY
+     */
+    async handleAnswer(clarificationId, answer, answeredBy) {
+        const updated = answerClarification(this.db, clarificationId, answer, answeredBy);
+        if (!updated) {
+            throw new Error(`澄清记录不存在: ${clarificationId}`);
+        }
+        const taskId = updated.task_id;
+        // 检查是否所有问题都已回答
+        const allClarifications = getClarifications(this.db, taskId);
+        const allAnswered = allClarifications.every(c => c.answer !== null);
+        if (allAnswered) {
+            const task = getTask(this.db, taskId);
+            if (task && task.status === TaskStatus.NEED_CLARIFICATION) {
+                updateTask(this.db, taskId, { status: TaskStatus.READY });
+            }
+        }
+    }
+}
+//# sourceMappingURL=clarifier.js.map

package/apps/server/dist/loid/context-builder.js

@@ -0,0 +1,413 @@
+import { getTask, getTasksByStatus, getRecentMessages, getMessageLogBySourceRef, } from "@team-anya/db";
+import { TaskStatus } from "@team-anya/core";
+import { memoryBrief } from "@team-anya/mcp-tools";
+export class LoidContextBuilder {
+    db;
+    workspacePath;
+    worktreeManager;
+    constructor(deps) {
+        this.db = deps.db;
+        this.workspacePath = deps.workspacePath;
+        this.worktreeManager = deps.worktreeManager;
+    }
+    /**
+     * 构建消息事件上下文（包含产品/项目注册表）
+     */
+    async buildMessageContext(message) {
+        const activeTasks = this.getActiveTasks();
+        const recentMessages = this.getRecentMessages(message.chatId);
+        const registry = await this.getRegistry();
+        if (registry.length > 0) {
+            const ids = registry.map((r) => r.id).join(", ");
+            console.log(`[ContextBuilder] 注入 registry: ${registry.length} 条 (${ids})`);
+        }
+        // 注入记忆摘要
+        let brief;
+        try {
+            const briefResult = await memoryBrief(this.workspacePath, {
+                sender_id: message.sender ?? undefined,
+                token_budget: 1500,
+            });
+            if (briefResult.brief) {
+                brief = briefResult.brief;
+            }
+        }
+        catch {
+            // 记忆摘要获取失败不阻塞主流程
+        }
+        return {
+            type: "new_message",
+            message,
+            activeTasks,
+            recentMessages,
+            registry,
+            memoryBrief: brief,
+        };
+    }
+    /**
+     * 构建交付验收上下文
+     */
+    buildDeliveryContext(taskId, exitCode, extras) {
+        const task = getTask(this.db, taskId);
+        const activeTasks = this.getActiveTasks();
+        return {
+            type: "delivery",
+            taskId,
+            briefContent: extras?.briefContent ?? null,
+            exitCode,
+            retryCount: task?.retry_count ?? 0,
+            maxRetries: task?.max_retries ?? 3,
+            prUrl: extras?.prUrl ?? task?.pr_url ?? null,
+            changedFiles: extras?.changedFiles ?? [],
+            testResults: extras?.testResults ?? null,
+            originalMessage: task?.context ?? null,
+            chatId: task?.source_ref
+                ? (getMessageLogBySourceRef(this.db, task.source_ref)?.chat_id ?? null)
+                : null,
+            conversationId: null,
+            activeTasks,
+            sourceChatId: task?.source_ref
+                ? (getMessageLogBySourceRef(this.db, task.source_ref)?.chat_id ??
+                    undefined)
+                : undefined,
+        };
+    }
+    /**
+     * 获取活跃任务列表
+     */
+    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.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;
+    }
+    /**
+     * 从 WorktreeManager 加载项目注册表
+     */
+    async getRegistry() {
+        try {
+            const config = await this.worktreeManager.loadConfig();
+            return config.projects.map((p) => ({
+                id: p.projectId,
+                name: p.name,
+                description: p.description,
+                repos: p.repos.map((r) => r.name),
+                claudeMd: p.claudeMd,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * 获取最近消息历史
+     */
+    getRecentMessages(chatId) {
+        try {
+            if (!chatId)
+                return [];
+            const messages = getRecentMessages(this.db, {
+                limit: 30,
+                chat_id: chatId,
+            });
+            const maxContentLen = 500;
+            return messages.map((m) => {
+                const raw = m.content ?? "";
+                // 从 metadata JSON 中提取 media、回复关系、sender_open_id
+                let media = [];
+                let replyTo = null;
+                let senderOpenId = null;
+                if (m.metadata) {
+                    try {
+                        const parsed = JSON.parse(m.metadata);
+                        if (Array.isArray(parsed.media)) {
+                            media = parsed.media.map((item) => ({
+                                mediaType: String(item.mediaType ?? "file"),
+                                originalName: String(item.originalName ?? ""),
+                                localPath: String(item.localPath ?? ""),
+                            }));
+                        }
+                        if (parsed.parent_message_id) {
+                            replyTo = String(parsed.parent_message_id);
+                        }
+                        if (parsed.sender_open_id) {
+                            senderOpenId = String(parsed.sender_open_id);
+                        }
+                    }
+                    catch {
+                        // metadata 解析失败，忽略
+                    }
+                }
+                return {
+                    message_id: m.source_ref ?? null,
+                    sender: m.sender,
+                    sender_open_id: senderOpenId,
+                    content: raw.slice(0, maxContentLen),
+                    direction: m.direction,
+                    created_at: m.created_at,
+                    message_type: m.message_type ?? null,
+                    related_task_id: m.related_task_id ?? null,
+                    reply_to: replyTo,
+                    media,
+                    truncated: raw.length > maxContentLen,
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// ── Prompt 格式化 ──
+export function formatMessageContextPrompt(ctx) {
+    const lines = [];
+    lines.push("强制执行步骤： 在生成任何回复之前，你必须先调用工具读取 CLAUDE.md 以及里面提到的所有的 md 文件。因为该文件中包含了决定你说话语气、你的灵魂，你的工作流程，以及你可以使用的工具（MCP）。即使你认为你知道答案，也严禁在未读取该文件的情况下直接回复。");
+    lines.push("--- 当前对话 ---");
+    const chatInfo = {
+        chat_id: ctx.message.chatId ?? null,
+        chat_type: ctx.message.isDirectMessage ? "p2p" : "group",
+    };
+    lines.push(JSON.stringify(chatInfo));
+    lines.push("");
+    lines.push("--- 当前事件 ---");
+    const event = {
+        type: "new_message",
+        message_id: ctx.message.metadata?.message_id ?? null,
+        sender_id: ctx.message.sender ?? "未知",
+        sender_name: ctx.message.senderName ?? null,
+        content: ctx.message.content,
+    };
+    if (ctx.message.mentionsAnya) {
+        event.mentions_anya = true;
+    }
+    if (ctx.message.metadata?.parent_message_id) {
+        event.reply_to = ctx.message.metadata.parent_message_id;
+    }
+    if (ctx.message.media.length > 0) {
+        event.media = ctx.message.media.map((m) => ({
+            type: m.mediaType,
+            name: m.originalName,
+            path: m.localPath,
+        }));
+    }
+    lines.push(JSON.stringify(event, null, 2));
+    if (ctx.message.media.length > 0) {
+        lines.push("");
+        lines.push("提示: 本条消息包含媒体附件，你可以通过 media.path 中的本地路径读取文件内容（图片可直接查看，文件可读取文本）。");
+    }
+    // 注入记忆摘要（在"当前状态"之前）
+    if (ctx.memoryBrief) {
+        lines.push("");
+        lines.push("--- 记忆摘要 ---");
+        lines.push(ctx.memoryBrief);
+    }
+    lines.push("");
+    lines.push("--- 当前状态 ---");
+    if (ctx.activeTasks.length > 0) {
+        lines.push("活跃任务:");
+        for (const t of ctx.activeTasks) {
+            lines.push(`  - [${t.status}] ${t.task_id}: ${t.title}${t.assignee ? ` (${t.assignee})` : ""}`);
+        }
+    }
+    else {
+        lines.push("活跃任务: 无");
+    }
+    if (ctx.recentMessages.length > 0) {
+        lines.push("");
+        lines.push("--- 对话历史 ---");
+        lines.push(`以下是当前对话最近 ${ctx.recentMessages.length} 条消息（时间倒序，最新在前）：`);
+        const history = ctx.recentMessages.map((m) => {
+            const entry = {
+                message_id: m.message_id,
+                time: m.created_at ?? "",
+                sender_id: m.direction === "outbound" ? "anya" : (m.sender_open_id ?? m.sender ?? "未知"),
+                sender_name: m.direction === "outbound" ? "Anya" : (m.sender ?? null),
+                direction: m.direction,
+                content: m.content,
+            };
+            if (m.reply_to) {
+                entry.reply_to = m.reply_to;
+            }
+            if (m.message_type && m.message_type !== "text") {
+                entry.message_type = m.message_type;
+            }
+            if (m.related_task_id) {
+                entry.related_task_id = m.related_task_id;
+            }
+            if (m.media.length > 0) {
+                entry.media = m.media.map((a) => ({
+                    type: a.mediaType,
+                    name: a.originalName,
+                    path: a.localPath,
+                }));
+            }
+            if (m.truncated) {
+                entry.truncated = true;
+            }
+            return entry;
+        });
+        lines.push(JSON.stringify(history, null, 2));
+    }
+    if (ctx.registry.length > 0) {
+        lines.push("");
+        lines.push("--- 可用项目 ---");
+        lines.push("派发任务时请通过 project_id 指定对应的项目:");
+        for (const entry of ctx.registry) {
+            const desc = entry.description ? ` — ${entry.description}` : "";
+            lines.push(`  - ${entry.id}: ${entry.name}${desc}`);
+            if (entry.repos.length > 0) {
+                lines.push(`    仓库: ${entry.repos.join(", ")}`);
+            }
+            if (entry.claudeMd) {
+                lines.push(`    技术栈:`);
+                for (const line of entry.claudeMd.split("\n")) {
+                    lines.push(`    ${line}`);
+                }
+            }
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * 合并多条缓冲消息为一个 prompt，供 Session drain 时投递给 CC
+ */
+export function formatBufferedMessages(messages) {
+    if (messages.length === 0)
+        return "";
+    const lines = [];
+    lines.push(`你在处理上一件事的过程中，该对话又收到了 ${messages.length} 条新消息：`);
+    lines.push("");
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const time = msg.message.metadata?.timestamp ?? "";
+        const sender = msg.message.senderName ?? msg.message.sender ?? "未知";
+        lines.push(`--- 消息 ${i + 1} (${time} 来自 ${sender}) ---`);
+        lines.push(msg.message.content);
+        if (msg.message.media.length > 0) {
+            for (const m of msg.message.media) {
+                lines.push(`  附件: [${m.mediaType}] ${m.originalName} (${m.localPath})`);
+            }
+        }
+        lines.push("");
+    }
+    lines.push("请综合这些新消息，决定下一步行动。");
+    return lines.join("\n");
+}
+/**
+ * 崩溃恢复时从 DB 活跃任务状态生成上下文 prompt
+ */
+export function formatRecoveryPrompt(activeTasks) {
+    const lines = [];
+    lines.push("--- 崩溃恢复 ---");
+    lines.push("上一个会话异常终止，以下是从数据库恢复的活跃任务状态：");
+    lines.push("");
+    if (activeTasks.length > 0) {
+        for (const t of activeTasks) {
+            lines.push(`- [${t.status}] ${t.task_id}: ${t.title}${t.assignee ? ` (负责人: ${t.assignee})` : ""}`);
+        }
+    }
+    else {
+        lines.push("当前无活跃任务。");
+    }
+    lines.push("");
+    lines.push("请根据以上状态，决定需要优先处理的事项。");
+    return lines.join("\n");
+}
+/**
+ * 后续消息精简格式：已有 session 时不重复注入对话历史、项目注册表、强制读 CLAUDE.md 指令
+ */
+export function formatFollowUpPrompt(ctx) {
+    const lines = [];
+    // 当前事件（必须）
+    lines.push("--- 新消息 ---");
+    const event = {
+        message_id: ctx.message.metadata?.message_id ?? null,
+        sender_id: ctx.message.sender ?? "未知",
+        sender_name: ctx.message.senderName ?? null,
+        content: ctx.message.content,
+    };
+    if (ctx.message.mentionsAnya)
+        event.mentions_anya = true;
+    if (ctx.message.metadata?.parent_message_id)
+        event.reply_to = ctx.message.metadata.parent_message_id;
+    if (ctx.message.media.length > 0) {
+        event.media = ctx.message.media.map((m) => ({
+            type: m.mediaType,
+            name: m.originalName,
+            path: m.localPath,
+        }));
+    }
+    lines.push(JSON.stringify(event, null, 2));
+    if (ctx.message.media.length > 0) {
+        lines.push("");
+        lines.push("提示: 本条消息包含媒体附件，你可以通过 media.path 中的本地路径读取文件内容。");
+    }
+    // 简化版记忆摘要（只注入人的记忆 summary）
+    if (ctx.memoryBrief) {
+        lines.push("");
+        lines.push("--- 记忆提示 ---");
+        lines.push(ctx.memoryBrief);
+    }
+    // 活跃任务（简洁版）
+    if (ctx.activeTasks.length > 0) {
+        lines.push("");
+        lines.push("--- 活跃任务 ---");
+        for (const t of ctx.activeTasks) {
+            lines.push(`  - [${t.status}] ${t.task_id}: ${t.title}${t.assignee ? ` (${t.assignee})` : ""}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function formatDeliveryContextPrompt(ctx) {
+    const lines = [];
+    lines.push("--- 当前事件 ---");
+    lines.push(`类型: Yor 交付`);
+    lines.push(`任务ID: ${ctx.taskId}`);
+    lines.push(`退出码: ${ctx.exitCode}`);
+    lines.push(`重试次数: ${ctx.retryCount}/${ctx.maxRetries}`);
+    if (ctx.prUrl) {
+        lines.push(`PR 链接: ${ctx.prUrl}`);
+    }
+    if (ctx.briefContent) {
+        lines.push("");
+        lines.push("原始 Brief:");
+        lines.push(ctx.briefContent);
+    }
+    if (ctx.changedFiles.length > 0) {
+        lines.push("");
+        lines.push("变更文件:");
+        for (const f of ctx.changedFiles) {
+            lines.push(`  - ${f}`);
+        }
+    }
+    if (ctx.testResults) {
+        lines.push("");
+        lines.push("测试结果:");
+        lines.push(ctx.testResults);
+    }
+    if (ctx.originalMessage) {
+        lines.push("");
+        lines.push(`原始用户指令: "${ctx.originalMessage}"`);
+    }
+    if (ctx.chatId) {
+        lines.push(`对话ID: ${ctx.chatId}（用于回复人类）`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=context-builder.js.map

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