team-anya-cli 0.1.0

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/profile-updater.js

@@ -0,0 +1,179 @@
+// ── ProfileUpdater ──
+/**
+ * 协作者画像自动更新
+ *
+ * 从任务交互中提取协作者特征，增量更新 memory/org/people/{person}.md
+ *
+ * 提取维度：
+ * - 响应速度：从 clarification_response 中统计平均响应时间
+ * - 沟通风格：从交互标签中聚合
+ * - 技术偏好：从 review_feedback 标签中提取
+ * - Review 反馈模式：统计 review 次数和情感倾向
+ */
+export class ProfileUpdater {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * 更新单人画像
+     */
+    async updateProfile(personId, interactions) {
+        const profile = { personId };
+        if (interactions.length === 0) {
+            return profile;
+        }
+        // 读取已有画像
+        const existingContent = await this.deps.readFile(`memory/people/${personId}.md`);
+        const existingProfile = existingContent ? this.parseExistingProfile(existingContent) : null;
+        // 提取响应速度
+        const responseTimes = interactions
+            .filter(i => i.type === 'clarification_response' && i.responseTimeMinutes !== undefined)
+            .map(i => i.responseTimeMinutes);
+        if (responseTimes.length > 0) {
+            const newAvg = responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
+            const newCount = responseTimes.length;
+            if (existingProfile?.responseSpeed) {
+                // 合并历史数据
+                const oldTotal = existingProfile.responseSpeed.avgMinutes * existingProfile.responseSpeed.sampleCount;
+                const newTotal = newAvg * newCount;
+                const totalCount = existingProfile.responseSpeed.sampleCount + newCount;
+                profile.responseSpeed = {
+                    avgMinutes: (oldTotal + newTotal) / totalCount,
+                    sampleCount: totalCount,
+                };
+            }
+            else {
+                profile.responseSpeed = {
+                    avgMinutes: newAvg,
+                    sampleCount: newCount,
+                };
+            }
+        }
+        // 提取沟通风格
+        const styleTags = interactions
+            .filter(i => i.tags && i.tags.length > 0)
+            .flatMap(i => i.tags);
+        if (styleTags.length > 0) {
+            profile.communicationStyle = [...new Set(styleTags)];
+        }
+        // 提取技术偏好
+        const techInteractions = interactions.filter(i => i.type === 'review_feedback');
+        const techPrefs = [];
+        for (const interaction of techInteractions) {
+            if (interaction.detail) {
+                techPrefs.push(interaction.detail);
+            }
+        }
+        if (techPrefs.length > 0) {
+            profile.technicalPreferences = techPrefs;
+        }
+        // Review 反馈模式
+        const reviews = interactions.filter(i => i.type === 'review_feedback');
+        if (reviews.length > 0) {
+            const sentiments = {};
+            for (const r of reviews) {
+                const s = r.sentiment ?? 'neutral';
+                sentiments[s] = (sentiments[s] ?? 0) + 1;
+            }
+            profile.reviewPatterns = {
+                totalReviews: reviews.length,
+                sentiments,
+            };
+        }
+        // 构建历史记录
+        profile.history = interactions.map(i => {
+            const date = i.timestamp.slice(0, 10);
+            return `- ${date}: [${i.taskId}] ${i.type}${i.detail ? ` - ${i.detail}` : ''}`;
+        });
+        // 渲染并写入
+        const rendered = this.renderProfile(profile, existingContent);
+        try {
+            await this.deps.memoryRemember({
+                category: 'people',
+                target: personId,
+                content: rendered,
+                importance: 0.5,
+            });
+        }
+        catch {
+            // 写入失败不影响返回
+        }
+        return profile;
+    }
+    /**
+     * 批量更新多人画像
+     */
+    async updateProfiles(interactions) {
+        // 按 personId 分组
+        const grouped = new Map();
+        for (const interaction of interactions) {
+            const existing = grouped.get(interaction.personId) ?? [];
+            existing.push(interaction);
+            grouped.set(interaction.personId, existing);
+        }
+        const results = {};
+        for (const [personId, personInteractions] of grouped) {
+            results[personId] = await this.updateProfile(personId, personInteractions);
+        }
+        return results;
+    }
+    // ── 内部方法 ──
+    parseExistingProfile(content) {
+        const profile = {};
+        // 解析响应速度
+        const avgMatch = /平均响应:\s*(\d+(?:\.\d+)?)\s*分钟/.exec(content);
+        const countMatch = /样本数:\s*(\d+)/.exec(content);
+        if (avgMatch && countMatch) {
+            profile.responseSpeed = {
+                avgMinutes: parseFloat(avgMatch[1]),
+                sampleCount: parseInt(countMatch[1], 10),
+            };
+        }
+        return profile;
+    }
+    renderProfile(profile, existingContent) {
+        const sections = [];
+        sections.push(`# ${profile.personId}`);
+        // 保留已有的基本信息 section
+        if (existingContent) {
+            const basicInfoMatch = /## 基本信息\n([\s\S]*?)(?=\n##\s|$)/.exec(existingContent);
+            if (basicInfoMatch) {
+                sections.push(`\n## 基本信息\n${basicInfoMatch[1].trimEnd()}`);
+            }
+        }
+        // 响应速度
+        if (profile.responseSpeed) {
+            sections.push(`\n## 响应速度\n- 平均响应: ${Math.round(profile.responseSpeed.avgMinutes * 10) / 10} 分钟\n- 样本数: ${profile.responseSpeed.sampleCount}`);
+        }
+        // 沟通风格
+        if (profile.communicationStyle && profile.communicationStyle.length > 0) {
+            sections.push(`\n## 沟通风格\n${profile.communicationStyle.map(s => `- ${s}`).join('\n')}`);
+        }
+        // 技术偏好
+        if (profile.technicalPreferences && profile.technicalPreferences.length > 0) {
+            sections.push(`\n## 技术偏好\n${profile.technicalPreferences.map(p => `- ${p}`).join('\n')}`);
+        }
+        // Review 模式
+        if (profile.reviewPatterns) {
+            const sentimentStr = Object.entries(profile.reviewPatterns.sentiments)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join(', ');
+            sections.push(`\n## Review 模式\n- 总 Review 数: ${profile.reviewPatterns.totalReviews}\n- 情感分布: ${sentimentStr}`);
+        }
+        // 历史记录
+        if (profile.history && profile.history.length > 0) {
+            // 保留已有历史
+            let existingHistory = '';
+            if (existingContent) {
+                const historyMatch = /## 历史记录\n([\s\S]*?)(?=\n##\s|$)/.exec(existingContent);
+                if (historyMatch) {
+                    existingHistory = historyMatch[1].trimEnd() + '\n';
+                }
+            }
+            sections.push(`\n## 历史记录\n${existingHistory}${profile.history.join('\n')}`);
+        }
+        return sections.join('\n') + '\n';
+    }
+}
+//# sourceMappingURL=profile-updater.js.map

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

@@ -0,0 +1,148 @@
+import { join } from 'node:path';
+// ── 进行中状态集合 ──
+const IN_PROGRESS_STATUSES = new Set(['IN_PROGRESS', 'TESTING', 'FIXING']);
+const PR_STATUSES = new Set(['PR_OPEN', 'WAITING_REVIEW']);
+// ── Reporter ──
+export class Reporter {
+    deps;
+    config;
+    constructor(deps, config) {
+        this.deps = deps;
+        this.config = config;
+    }
+    /**
+     * 生成日报 Markdown 内容
+     */
+    async generateDailyReport(date) {
+        const allTasks = this.deps.getAllTasks();
+        const commitments = this.deps.getActiveCommitments();
+        const opportunities = this.deps.getOpenOpportunities();
+        const auditEvents = this.deps.getAuditEventsByDate(date);
+        const lines = [];
+        const done = allTasks.filter((t) => t.status === 'DONE' && t.updated_at?.startsWith(date));
+        const prOpen = allTasks.filter((t) => PR_STATUSES.has(t.status));
+        const inProgress = allTasks.filter((t) => IN_PROGRESS_STATUSES.has(t.status));
+        const blocked = allTasks.filter((t) => t.status === 'BLOCKED');
+        // 开头一句话总结
+        const totalActive = inProgress.length + prOpen.length;
+        if (done.length > 0 && blocked.length === 0) {
+            lines.push(`今天完成了 ${done.length} 个任务${totalActive > 0 ? `，还有 ${totalActive} 个在跑` : ''}。\n`);
+        }
+        else if (done.length > 0 && blocked.length > 0) {
+            lines.push(`今天完成了 ${done.length} 个任务，但有 ${blocked.length} 个卡住了。\n`);
+        }
+        else if (blocked.length > 0) {
+            lines.push(`有 ${blocked.length} 个任务卡住了，需要关注。\n`);
+        }
+        else if (totalActive > 0) {
+            lines.push(`${totalActive} 个任务进行中。\n`);
+        }
+        // 完成的
+        if (done.length > 0) {
+            lines.push('**已完成**');
+            for (const t of done) {
+                const pr = t.pr_url ? ` → ${t.pr_url}` : '';
+                lines.push(`- ${t.title} (${t.task_id})${pr}`);
+            }
+            lines.push('');
+        }
+        // 等 Review 的
+        if (prOpen.length > 0) {
+            lines.push('**等 Review**');
+            for (const t of prOpen) {
+                const pr = t.pr_url ? ` → ${t.pr_url}` : '';
+                lines.push(`- ${t.title} (${t.task_id})${pr}`);
+            }
+            lines.push('');
+        }
+        // 进行中的
+        if (inProgress.length > 0) {
+            lines.push('**进行中**');
+            for (const t of inProgress) {
+                lines.push(`- ${t.title} (${t.task_id})`);
+            }
+            lines.push('');
+        }
+        // 卡住的（重点标出）
+        if (blocked.length > 0) {
+            lines.push('**卡住了**');
+            for (const t of blocked) {
+                lines.push(`- ${t.title} (${t.task_id}) — ${t.blocked_reason ?? '原因待查'}`);
+            }
+            lines.push('');
+        }
+        // 承诺追踪
+        if (commitments.length > 0) {
+            lines.push('**还欠着的**');
+            for (const c of commitments) {
+                const deadline = c.deadline ? `，截止 ${c.deadline}` : '';
+                lines.push(`- ${c.promise} (答应 ${c.promised_to} 的${deadline})`);
+            }
+            lines.push('');
+        }
+        // 机会
+        if (opportunities.length > 0) {
+            lines.push('**发现了几个可以做的事**');
+            for (const o of opportunities) {
+                lines.push(`- ${o.summary}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 将日报写入文件
+     */
+    async saveDailyReport(date, content) {
+        const reportsDir = join(this.config.workspacePath, 'reports');
+        await this.deps.mkdirp(reportsDir);
+        const filePath = join(reportsDir, `daily-${date}.md`);
+        await this.deps.writeFile(filePath, content);
+        return filePath;
+    }
+    /**
+     * 端到端：生成 + 写文件 + 飞书推送
+     */
+    async publishDailyReport(date) {
+        const content = await this.generateDailyReport(date);
+        // 写文件（总是执行）
+        await this.saveDailyReport(date, content);
+        // 飞书推送（可选，失败不影响文件写入）
+        if (this.config.feishuDailyReportChatId) {
+            try {
+                await this.deps.sendDailyReport({
+                    chatId: this.config.feishuDailyReportChatId,
+                    reportContent: content,
+                    date,
+                });
+            }
+            catch {
+                // 飞书发送失败不影响日报文件保存
+            }
+        }
+    }
+    /**
+     * 实时告警：任务 BLOCKED
+     */
+    async notifyBlocked(params) {
+        await this.deps.sendBlockedAlert({
+            targetUserIds: params.targetUserIds,
+            taskId: params.taskId,
+            reason: params.reason,
+        });
+    }
+    /**
+     * 任务完成通知
+     */
+    async notifyTaskDone(params) {
+        if (!params.chatId)
+            return;
+        await this.deps.sendTaskDone({
+            chatId: params.chatId,
+            taskId: params.taskId,
+            prUrl: params.prUrl,
+            summary: params.summary,
+        });
+    }
+}
+//# sourceMappingURL=reporter.js.map