team-anya 0.1.0

package/apps/server/dist/loid/brief-assembler.js

@@ -0,0 +1,156 @@
+// ── 本地类型定义（避免对 mcp-tools 内部类型的直接依赖）──
+// ── 粗略 token 估算 ──
+function estimateTokens(text) {
+    // 粗略估算：中文 ~1.5 token/字，英文 ~0.25 token/word
+    // 简化为 1 token ≈ 3 字符
+    return Math.ceil(text.length / 3);
+}
+// ── BriefAssembler ──
+export class BriefAssembler {
+    deps;
+    maxTokenBudget;
+    constructor(deps, options) {
+        this.deps = deps;
+        this.maxTokenBudget = options?.maxTokenBudget ?? 4000;
+    }
+    /**
+     * 收集 brief 所需的全部数据
+     */
+    async gatherData(taskId) {
+        // taskContext 是必须的，失败则直接抛出
+        const ctx = await this.deps.getTaskContext(taskId);
+        // 并行收集可选数据（失败安全降级）
+        const [memoryResult, orgResult] = await Promise.allSettled([
+            this.deps.searchMemory(ctx.task.title + ' ' + (ctx.task.objective ?? ''), ctx.task.project_id ?? undefined, ['pitfall', 'decision']),
+            this.deps.lookupOrg(ctx.task.project_id ?? undefined),
+        ]);
+        const memories = memoryResult.status === 'fulfilled'
+            ? memoryResult.value.results
+            : [];
+        const orgData = orgResult.status === 'fulfilled'
+            ? orgResult.value
+            : { ownership: [], escalation_path: [] };
+        return {
+            task: ctx.task,
+            clarifications: ctx.clarifications,
+            memories,
+            ownership: orgData.ownership ?? [],
+            escalationPath: orgData.escalation_path ?? [],
+            executionGuidance: ctx.task.execution_guidance,
+        };
+    }
+    /**
+     * 将收集到的数据渲染为 brief.md
+     *
+     * 只写"做什么、做到什么程度"，不写"怎么做"
+     *
+     * Token 预算优先级：验收标准 > 踩坑 > 决策 > 联系方式
+     */
+    renderBrief(data) {
+        const sections = [];
+        let usedTokens = 0;
+        // Header（最高优先级，不计预算）
+        const header = `# Brief: ${data.task.title}\n\n> Task ID: ${data.task.task_id}\n`;
+        usedTokens += estimateTokens(header);
+        // 1. What — 目标（最高优先级）
+        if (data.task.objective) {
+            const objectiveSection = `## What\n\n${data.task.objective}\n`;
+            sections.push({ priority: 0, content: objectiveSection });
+        }
+        // 2. DoD — 验收标准（最高优先级）
+        const criteria = this.parseAcceptanceCriteria(data.task.acceptance_criteria);
+        if (criteria.length > 0) {
+            const criteriaSection = `## DoD\n\n${criteria.map(c => `- ${c}`).join('\n')}\n`;
+            sections.push({ priority: 1, content: criteriaSection });
+        }
+        // 3. Why — 背景（高优先级）
+        if (data.task.context) {
+            let bgContent = data.task.context;
+            // 附加澄清信息
+            const answeredClarifications = data.clarifications.filter(c => c.answer);
+            if (answeredClarifications.length > 0) {
+                bgContent += '\n\n**补充澄清：**\n' +
+                    answeredClarifications.map(c => `- Q: ${c.question}\n  A: ${c.answer}`).join('\n');
+            }
+            const bgSection = `## Why\n\n${bgContent}\n`;
+            sections.push({ priority: 2, content: bgSection });
+        }
+        // 4. 执行指引（高优先级，介于背景与约束之间）
+        const guidanceText = data.executionGuidance || '将结果写入 scratch/result.md';
+        const guidanceSection = `## 执行指引\n\n${guidanceText}\n`;
+        sections.push({ priority: 2.5, content: guidanceSection });
+        // 5. Constraints — 约束条件（高优先级）
+        const constraints = [];
+        if (data.task.project_id) {
+            constraints.push(`项目: ${data.task.project_id}`);
+        }
+        if (data.ownership && data.ownership.length > 0) {
+            constraints.push(...data.ownership.map(o => `${o.target} → ${o.member_id} (${o.role})`));
+        }
+        if (data.escalationPath && data.escalationPath.length > 0) {
+            constraints.push(...data.escalationPath.map(e => `${e.after_minutes} 分钟后: ${e.action} → ${e.targets.join(', ')}`));
+        }
+        if (constraints.length > 0) {
+            const constraintsSection = `## Constraints\n\n${constraints.map(c => `- ${c}`).join('\n')}\n`;
+            sections.push({ priority: 3, content: constraintsSection });
+        }
+        // 7. 历史经验 — 踩坑（中优先级）
+        const pitfalls = data.memories.filter(m => m.type === 'pitfall');
+        if (pitfalls.length > 0) {
+            const pitfallSection = `## 历史踩坑\n\n${pitfalls.map(p => `- ${p.content}`).join('\n')}\n`;
+            sections.push({ priority: 4, content: pitfallSection });
+        }
+        // 8. 历史经验 — 决策（中低优先级）
+        const decisions = data.memories.filter(m => m.type === 'decision');
+        if (decisions.length > 0) {
+            const decisionSection = `## 历史决策\n\n${decisions.map(d => `- ${d.content}`).join('\n')}\n`;
+            sections.push({ priority: 5, content: decisionSection });
+        }
+        // 按优先级排序
+        sections.sort((a, b) => a.priority - b.priority);
+        // Token 预算控制
+        const result = [header];
+        for (const section of sections) {
+            const sectionTokens = estimateTokens(section.content);
+            if (usedTokens + sectionTokens <= this.maxTokenBudget) {
+                result.push(section.content);
+                usedTokens += sectionTokens;
+            }
+            else {
+                // 尝试截断
+                const remainingBudget = this.maxTokenBudget - usedTokens;
+                if (remainingBudget > 50) {
+                    // 至少留 50 token 才截断
+                    const maxChars = remainingBudget * 3;
+                    const truncated = section.content.slice(0, maxChars) + '\n\n…(已截断)\n';
+                    result.push(truncated);
+                    usedTokens = this.maxTokenBudget;
+                }
+                break;
+            }
+        }
+        return result.join('\n');
+    }
+    /**
+     * 端到端方法：收集数据 + 渲染 brief
+     */
+    async assembleBrief(taskId) {
+        const data = await this.gatherData(taskId);
+        return this.renderBrief(data);
+    }
+    /**
+     * 解析验收标准（JSON 数组字符串或 null）
+     */
+    parseAcceptanceCriteria(ac) {
+        if (!ac)
+            return [];
+        try {
+            const parsed = JSON.parse(ac);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=brief-assembler.js.map

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/commitment-tracker.js

@@ -0,0 +1,236 @@
+import { EventEmitter } from 'node:events';
+import { createCommitment, getCommitment, getActiveCommitments, updateCommitment, } from '@team-anya/db';
+/**
+ * 承诺追踪器：自动提取、追踪、检测逾期承诺
+ */
+export class CommitmentTracker extends EventEmitter {
+    db;
+    workspacePath;
+    intervalHandle = null;
+    constructor(deps) {
+        super();
+        this.db = deps.db;
+        this.workspacePath = deps.workspacePath;
+    }
+    /**
+     * 从任务文本中提取承诺
+     * 识别模式：
+     * - "向 @xxx 承诺...（动作）"
+     * - "我会在...之前完成/交付..."
+     * - "承诺给 @xxx 在...之前..."
+     * - "保证给 @xxx 在...前..."
+     * - "告知 @xxx 我会在...之前..."
+     */
+    async extractCommitments(task, context) {
+        const commitments = [];
+        const patterns = this.buildPatterns();
+        for (const pattern of patterns) {
+            const matches = context.matchAll(pattern.regex);
+            for (const match of matches) {
+                const extracted = pattern.extract(match, task.task_id);
+                if (extracted && !this.isDuplicate(commitments, extracted)) {
+                    commitments.push(extracted);
+                }
+            }
+        }
+        // 保存到数据库
+        const saved = [];
+        for (const c of commitments) {
+            const record = createCommitment(this.db, {
+                task_id: c.task_id,
+                promised_to: c.promised_to,
+                promise: c.promise,
+                deadline: c.deadline,
+                status: 'active',
+            });
+            saved.push({
+                id: record.id,
+                task_id: record.task_id,
+                promised_to: record.promised_to,
+                promise: record.promise,
+                deadline: record.deadline,
+                status: record.status,
+            });
+        }
+        return saved;
+    }
+    /**
+     * 扫描逾期承诺，将其标记为 broken
+     */
+    async checkOverdue() {
+        const active = getActiveCommitments(this.db);
+        const now = new Date();
+        const overdue = [];
+        for (const c of active) {
+            if (!c.deadline)
+                continue;
+            const deadlineDate = new Date(c.deadline);
+            if (deadlineDate < now) {
+                updateCommitment(this.db, c.id, {
+                    status: 'broken',
+                    break_reason: `逾期：deadline ${c.deadline} 已过`,
+                });
+                overdue.push({
+                    id: c.id,
+                    task_id: c.task_id,
+                    promised_to: c.promised_to,
+                    promise: c.promise,
+                    deadline: c.deadline,
+                    status: 'broken',
+                });
+            }
+        }
+        if (overdue.length > 0) {
+            this.emit('overdue', overdue);
+        }
+        return overdue;
+    }
+    /**
+     * 标记承诺已兑现
+     */
+    async fulfillCommitment(id) {
+        const existing = getCommitment(this.db, id);
+        if (!existing) {
+            throw new Error(`承诺不存在: id=${id}`);
+        }
+        updateCommitment(this.db, id, { status: 'fulfilled' });
+    }
+    /**
+     * 取消承诺
+     */
+    async cancelCommitment(id, reason) {
+        const existing = getCommitment(this.db, id);
+        if (!existing) {
+            throw new Error(`承诺不存在: id=${id}`);
+        }
+        updateCommitment(this.db, id, {
+            status: 'cancelled',
+            break_reason: reason,
+        });
+    }
+    /**
+     * 启动定时逾期扫描
+     */
+    startPeriodicCheck(intervalMs) {
+        this.stopPeriodicCheck();
+        this.intervalHandle = setInterval(async () => {
+            await this.checkOverdue();
+        }, intervalMs);
+    }
+    /**
+     * 停止定时扫描
+     */
+    stopPeriodicCheck() {
+        if (this.intervalHandle) {
+            clearInterval(this.intervalHandle);
+            this.intervalHandle = null;
+        }
+    }
+    // ── 私有方法 ──
+    buildPatterns() {
+        return [
+            // "向 @xxx 承诺在...之前..."
+            {
+                regex: /向\s*(@\w+)\s*承诺在?\s*(.+?)之前\s*(.+?)(?:[。，；\n]|$)/g,
+                extract: (m, taskId) => ({
+                    task_id: taskId,
+                    promised_to: m[1],
+                    promise: m[3].trim(),
+                    deadline: this.parseFuzzyDate(m[2].trim()),
+                    status: 'active',
+                }),
+            },
+            // "承诺给 @xxx 在...之前交付/完成..."
+            {
+                regex: /承诺给?\s*(@\w+)\s*在?\s*(.+?)之前\s*(.+?)(?:[。，；\n]|$)/g,
+                extract: (m, taskId) => ({
+                    task_id: taskId,
+                    promised_to: m[1],
+                    promise: m[3].trim(),
+                    deadline: this.parseFuzzyDate(m[2].trim()),
+                    status: 'active',
+                }),
+            },
+            // "保证给 @xxx 在...前完成..."
+            {
+                regex: /保证给?\s*(@\w+)\s*在?\s*(.+?)前\s*(.+?)(?:[。，；\n]|$)/g,
+                extract: (m, taskId) => ({
+                    task_id: taskId,
+                    promised_to: m[1],
+                    promise: m[3].trim(),
+                    deadline: this.parseFuzzyDate(m[2].trim()),
+                    status: 'active',
+                }),
+            },
+            // "告知 @xxx 我会在...之前..."
+            {
+                regex: /告知\s*(@\w+)\s*我会在?\s*(.+?)之前\s*(.+?)(?:[。，；\n]|$)/g,
+                extract: (m, taskId) => ({
+                    task_id: taskId,
+                    promised_to: m[1],
+                    promise: m[3].trim(),
+                    deadline: this.parseFuzzyDate(m[2].trim()),
+                    status: 'active',
+                }),
+            },
+            // "@xxx ...我会在...之前完成..."  (generic pattern with @mention + deadline)
+            {
+                regex: /(@\w+)\s*.{0,20}我会在?\s*(.+?)之前\s*(完成|交付|修复|解决).+?(?:[。，；\n]|$)/g,
+                extract: (m, taskId) => ({
+                    task_id: taskId,
+                    promised_to: m[1],
+                    promise: `${m[3]}${m[0].slice(m[0].indexOf(m[3]) + m[3].length).replace(/[。，；\n]+$/, '')}`.trim() || m[3],
+                    deadline: this.parseFuzzyDate(m[2].trim()),
+                    status: 'active',
+                }),
+            },
+        ];
+    }
+    /**
+     * 解析模糊日期描述为 ISO 字符串
+     */
+    parseFuzzyDate(text) {
+        // 精确日期格式
+        const dateMatch = text.match(/(\d{4}-\d{2}-\d{2})/);
+        if (dateMatch) {
+            return `${dateMatch[1]}T23:59:59.000Z`;
+        }
+        const now = new Date();
+        // "明天"
+        if (text.includes('明天')) {
+            const tomorrow = new Date(now);
+            tomorrow.setDate(tomorrow.getDate() + 1);
+            return `${tomorrow.toISOString().slice(0, 10)}T23:59:59.000Z`;
+        }
+        // "后天"
+        if (text.includes('后天')) {
+            const dayAfter = new Date(now);
+            dayAfter.setDate(dayAfter.getDate() + 2);
+            return `${dayAfter.toISOString().slice(0, 10)}T23:59:59.000Z`;
+        }
+        // "本周五" / "周五" / "本周X"
+        const weekDayMatch = text.match(/(?:本)?周([一二三四五六日天])/);
+        if (weekDayMatch) {
+            const dayMap = {
+                '一': 1, '二': 2, '三': 3, '四': 4,
+                '五': 5, '六': 6, '日': 0, '天': 0,
+            };
+            const targetDay = dayMap[weekDayMatch[1]];
+            const currentDay = now.getDay();
+            let daysUntil = targetDay - currentDay;
+            if (daysUntil <= 0)
+                daysUntil += 7;
+            const target = new Date(now);
+            target.setDate(target.getDate() + daysUntil);
+            return `${target.toISOString().slice(0, 10)}T23:59:59.000Z`;
+        }
+        return null;
+    }
+    /**
+     * 检查是否重复（同一人+同一承诺内容）
+     */
+    isDuplicate(existing, candidate) {
+        return existing.some(e => e.promised_to === candidate.promised_to && e.promise === candidate.promise);
+    }
+}
+//# sourceMappingURL=commitment-tracker.js.map