team-anya 0.2.0

package/apps/server/dist/loid/self-calibrator.js

@@ -0,0 +1,314 @@
+/**
+ * SelfCalibrator - 自我校准模块
+ *
+ * 从执行结果中自动校准能力评估：
+ * - 统计成功率（按项目/类型分组）
+ * - 识别常见失败模式
+ * - 计算自愈成功率
+ * - 更新 capability-notes.md
+ * - 提供项目风险提示
+ */
+import { getAllTasks, getAuditEventsByType, insertAuditEvent } from '@team-anya/db';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+// ── 终态状态集 ──
+const TERMINAL_STATUSES = new Set(['DONE', 'CANCELLED']);
+const SUCCESS_STATUSES = new Set(['DONE']);
+// ── 实现 ──
+export class SelfCalibrator {
+    db;
+    workspacePath;
+    _lastStatus = {
+        lastCalibratedAt: null,
+        report: null,
+        deviationFactors: null,
+        warnings: [],
+    };
+    constructor(opts) {
+        this.db = opts.db;
+        this.workspacePath = opts.workspacePath;
+    }
+    /**
+     * 计算执行统计数据
+     */
+    computeStats() {
+        const allTasks = getAllTasks(this.db);
+        const terminalTasks = allTasks.filter(t => TERMINAL_STATUSES.has(t.status));
+        const successTasks = terminalTasks.filter(t => SUCCESS_STATUSES.has(t.status));
+        const totalCompleted = terminalTasks.length;
+        const successCount = successTasks.length;
+        const successRate = totalCompleted > 0 ? successCount / totalCompleted : 0;
+        // 平均重试次数
+        const avgRetryCount = totalCompleted > 0
+            ? terminalTasks.reduce((sum, t) => sum + (t.retry_count ?? 0), 0) / totalCompleted
+            : 0;
+        // 按项目分组
+        const byProject = {};
+        for (const task of terminalTasks) {
+            const pid = task.project_id;
+            if (!pid)
+                continue;
+            if (!byProject[pid]) {
+                byProject[pid] = { total: 0, success: 0, successRate: 0 };
+            }
+            byProject[pid].total++;
+            if (SUCCESS_STATUSES.has(task.status)) {
+                byProject[pid].success++;
+            }
+        }
+        for (const group of Object.values(byProject)) {
+            group.successRate = group.total > 0 ? group.success / group.total : 0;
+        }
+        // 按 source_type 分组
+        const bySourceType = {};
+        for (const task of terminalTasks) {
+            const st = task.source_type;
+            if (!bySourceType[st]) {
+                bySourceType[st] = { total: 0, success: 0, successRate: 0 };
+            }
+            bySourceType[st].total++;
+            if (SUCCESS_STATUSES.has(task.status)) {
+                bySourceType[st].success++;
+            }
+        }
+        for (const group of Object.values(bySourceType)) {
+            group.successRate = group.total > 0 ? group.success / group.total : 0;
+        }
+        return { totalCompleted, successCount, successRate, avgRetryCount, byProject, bySourceType };
+    }
+    /**
+     * 分析失败模式（从 task_blocked 审计事件中提取）
+     */
+    analyzeFailurePatterns() {
+        const blockedEvents = getAuditEventsByType(this.db, 'task_blocked');
+        const patternMap = new Map();
+        for (const event of blockedEvents) {
+            if (!event.detail)
+                continue;
+            try {
+                const detail = JSON.parse(event.detail);
+                const reason = detail.reason;
+                if (!reason)
+                    continue;
+                const existing = patternMap.get(reason);
+                if (existing) {
+                    existing.count++;
+                }
+                else {
+                    patternMap.set(reason, { count: 1, type: detail.type });
+                }
+            }
+            catch {
+                // detail 不是有效 JSON，跳过
+            }
+        }
+        const patterns = [];
+        for (const [pattern, data] of patternMap) {
+            patterns.push({ pattern, count: data.count, type: data.type });
+        }
+        // 按出现次数降序排列
+        patterns.sort((a, b) => b.count - a.count);
+        return patterns;
+    }
+    /**
+     * 计算自愈成功率
+     */
+    computeSelfHealRate() {
+        const healEvents = getAuditEventsByType(this.db, 'self_heal_attempt');
+        if (healEvents.length === 0) {
+            return { total: 0, succeeded: 0, rate: 0 };
+        }
+        let succeeded = 0;
+        for (const event of healEvents) {
+            if (!event.detail)
+                continue;
+            try {
+                const detail = JSON.parse(event.detail);
+                if (detail.success)
+                    succeeded++;
+            }
+            catch {
+                // 跳过
+            }
+        }
+        return {
+            total: healEvents.length,
+            succeeded,
+            rate: healEvents.length > 0 ? succeeded / healEvents.length : 0,
+        };
+    }
+    /**
+     * 生成完整的校准报告
+     */
+    generateReport() {
+        return {
+            stats: this.computeStats(),
+            failurePatterns: this.analyzeFailurePatterns(),
+            selfHealRate: this.computeSelfHealRate(),
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * 更新 capability-notes.md 文件
+     */
+    async updateCapabilityNotes() {
+        const report = this.generateReport();
+        const content = this.formatCapabilityNotes(report);
+        const notesPath = join(this.workspacePath, 'memory', 'self', 'capability-notes.md');
+        await writeFile(notesPath, content, 'utf-8');
+    }
+    /**
+     * 获取指定项目的风险提示
+     */
+    getRiskHints(projectId) {
+        const stats = this.computeStats();
+        const projectStats = stats.byProject[projectId];
+        const hints = [];
+        if (!projectStats)
+            return hints;
+        // 低成功率警告（< 50%）
+        if (projectStats.successRate < 0.5) {
+            hints.push(`该项目成功率偏低 (${(projectStats.successRate * 100).toFixed(0)}%)，建议关注失败原因`);
+        }
+        // 高重试率警告（平均重试 >= 2）
+        const projectTasks = getAllTasks(this.db).filter(t => t.project_id === projectId && TERMINAL_STATUSES.has(t.status));
+        if (projectTasks.length > 0) {
+            const avgRetry = projectTasks.reduce((sum, t) => sum + (t.retry_count ?? 0), 0) / projectTasks.length;
+            if (avgRetry >= 2) {
+                hints.push(`该项目平均重试次数较高 (${avgRetry.toFixed(1)}次)，可能存在系统性问题`);
+            }
+        }
+        return hints;
+    }
+    /**
+     * 计算偏差校正因子
+     */
+    computeDeviationFactors() {
+        const allTasks = getAllTasks(this.db);
+        const terminalTasks = allTasks.filter(t => TERMINAL_STATUSES.has(t.status));
+        // 重试偏差：平均 retry_count / max_retries
+        let retryDeviation = 0;
+        if (terminalTasks.length > 0) {
+            const ratios = terminalTasks.map(t => {
+                const maxRetries = t.max_retries ?? 3;
+                if (maxRetries === 0)
+                    return 0;
+                return (t.retry_count ?? 0) / maxRetries;
+            });
+            retryDeviation = ratios.reduce((a, b) => a + b, 0) / ratios.length;
+        }
+        // 承诺达成率
+        const fulfilledEvents = getAuditEventsByType(this.db, 'commitment_fulfilled');
+        const brokenEvents = getAuditEventsByType(this.db, 'commitment_broken');
+        const totalCommitmentEvents = fulfilledEvents.length + brokenEvents.length;
+        const commitmentFulfillRate = totalCommitmentEvents > 0
+            ? fulfilledEvents.length / totalCommitmentEvents
+            : 0;
+        // 校正因子：retryDeviation 越高说明低估复杂度
+        // 0 偏差 → 1.0（无需校正），1.0 偏差 → 1.5（需要 50% 更多缓冲）
+        const correctionFactor = terminalTasks.length > 0
+            ? 1.0 + retryDeviation * 0.5
+            : 1.0;
+        return { retryDeviation, commitmentFulfillRate, correctionFactor };
+    }
+    /**
+     * 执行一次完整校准，记录审计事件并缓存状态
+     */
+    runCalibration() {
+        const report = this.generateReport();
+        const deviationFactors = this.computeDeviationFactors();
+        const now = new Date().toISOString();
+        // 生成偏差警告
+        const warnings = [];
+        const RETRY_DEVIATION_THRESHOLD = 0.7;
+        if (deviationFactors.retryDeviation >= RETRY_DEVIATION_THRESHOLD) {
+            warnings.push(`重试偏差过高 (${(deviationFactors.retryDeviation * 100).toFixed(0)}%)，建议调整复杂度预估`);
+        }
+        if (report.stats.successRate < 0.5 && report.stats.totalCompleted > 0) {
+            warnings.push(`整体成功率偏低 (${(report.stats.successRate * 100).toFixed(0)}%)，需要关注系统性问题`);
+        }
+        // 记录审计事件
+        insertAuditEvent(this.db, {
+            event_type: 'calibration',
+            actor: 'loid',
+            summary: `自我校准完成: 成功率 ${(report.stats.successRate * 100).toFixed(1)}%, 校正因子 ${deviationFactors.correctionFactor.toFixed(2)}`,
+            detail: JSON.stringify({
+                stats: report.stats,
+                deviationFactors,
+                warnings,
+            }),
+        });
+        // 缓存状态
+        this._lastStatus = {
+            lastCalibratedAt: now,
+            report,
+            deviationFactors,
+            warnings,
+        };
+        return this._lastStatus;
+    }
+    /**
+     * 获取当前校准状态（返回上次 runCalibration 的缓存）
+     */
+    getCalibrationStatus() {
+        return this._lastStatus;
+    }
+    // ── 私有方法 ──
+    formatCapabilityNotes(report) {
+        const { stats, failurePatterns, selfHealRate } = report;
+        if (stats.totalCompleted === 0 && failurePatterns.length === 0 && selfHealRate.total === 0) {
+            return `# Anya Capability Notes\n\n> 自动生成于 ${report.generatedAt}\n\n无数据 — 尚无已完成的任务记录。\n`;
+        }
+        const lines = [
+            '# Anya Capability Notes',
+            '',
+            `> 自动生成于 ${report.generatedAt}`,
+            '',
+            '## 执行统计',
+            '',
+            `- 已完成任务: ${stats.totalCompleted}`,
+            `- 成功数: ${stats.successCount}`,
+            `- 整体成功率: ${(stats.successRate * 100).toFixed(1)}%`,
+            `- 平均重试次数: ${stats.avgRetryCount.toFixed(1)}`,
+            '',
+        ];
+        // 项目分组统计
+        const projectIds = Object.keys(stats.byProject);
+        if (projectIds.length > 0) {
+            lines.push('### 按项目', '');
+            for (const pid of projectIds) {
+                const g = stats.byProject[pid];
+                lines.push(`- **${pid}**: ${g.success}/${g.total} (成功率 ${(g.successRate * 100).toFixed(1)}%)`);
+            }
+            lines.push('');
+        }
+        // source_type 分组统计
+        const sourceTypes = Object.keys(stats.bySourceType);
+        if (sourceTypes.length > 0) {
+            lines.push('### 按来源类型', '');
+            for (const st of sourceTypes) {
+                const g = stats.bySourceType[st];
+                lines.push(`- **${st}**: ${g.success}/${g.total} (成功率 ${(g.successRate * 100).toFixed(1)}%)`);
+            }
+            lines.push('');
+        }
+        // 失败模式
+        if (failurePatterns.length > 0) {
+            lines.push('## 失败模式', '');
+            for (const p of failurePatterns) {
+                lines.push(`- **${p.pattern}**: ${p.count}次${p.type ? ` (类型: ${p.type})` : ''}`);
+            }
+            lines.push('');
+        }
+        // 自愈成功率
+        if (selfHealRate.total > 0) {
+            lines.push('## 自愈能力', '');
+            lines.push(`- 自愈尝试: ${selfHealRate.total}次`);
+            lines.push(`- 自愈成功: ${selfHealRate.succeeded}次`);
+            lines.push(`- 自愈成功率: ${(selfHealRate.rate * 100).toFixed(1)}%`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+//# sourceMappingURL=self-calibrator.js.map