principles-disciple 1.5.4 → 1.6.0

package/dist/core/event-log.js

@@ -57,6 +57,9 @@ export class EventLog {
     recordTrustChange(sessionId, data) {
         this.record('trust_change', 'changed', sessionId, data);
     }
+    recordEmpathyRollback(sessionId, data) {
+        this.record('empathy_rollback', 'rolled_back', sessionId, data);
+    }
     recordError(sessionId, message, context) {
         this.record('error', 'failure', sessionId, { message, ...context });
     }
@@ -115,6 +118,45 @@ export class EventLog {
             const data = entry.data;
             stats.pain.signalsDetected++;
             stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
+            // Update empathy stats for user_empathy source
+            if (data.source === 'user_empathy') {
+                if (data.deduped) {
+                    stats.empathy.dedupedCount++;
+                }
+                else {
+                    stats.empathy.totalEvents++;
+                    stats.empathy.totalPenaltyScore += data.score || 0;
+                    // By severity
+                    if (data.severity) {
+                        stats.empathy.bySeverity[data.severity]++;
+                        stats.empathy.scoreBySeverity[data.severity] += data.score || 0;
+                    }
+                    // By detection mode
+                    if (data.detection_mode) {
+                        stats.empathy.byDetectionMode[data.detection_mode]++;
+                    }
+                    // By origin
+                    if (data.origin) {
+                        stats.empathy.byOrigin[data.origin]++;
+                    }
+                    // Confidence distribution
+                    const conf = data.confidence ?? 1;
+                    if (conf >= 0.8)
+                        stats.empathy.confidenceDistribution.high++;
+                    else if (conf >= 0.5)
+                        stats.empathy.confidenceDistribution.medium++;
+                    else
+                        stats.empathy.confidenceDistribution.low++;
+                }
+                // Update dedupe hit rate
+                const total = stats.empathy.totalEvents + stats.empathy.dedupedCount;
+                stats.empathy.dedupeHitRate = total > 0 ? stats.empathy.dedupedCount / total : 0;
+            }
+        }
+        else if (entry.type === 'empathy_rollback') {
+            const data = entry.data;
+            stats.empathy.rollbackCount++;
+            stats.empathy.rolledBackScore += data.originalScore || 0;
         }
     }
     startFlushTimer() {
@@ -164,6 +206,280 @@ export class EventLog {
         }
         return stats;
     }
+    /**
+     * Get aggregated empathy statistics for multiple time ranges.
+     * @param range 'today' | 'week' | 'session'
+     * @param sessionId Optional session ID for session-scoped stats
+     */
+    getEmpathyStats(range, sessionId) {
+        const now = new Date();
+        const today = this.formatDate(now);
+        // Aggregate stats based on range
+        const result = {
+            totalEvents: 0,
+            dedupedCount: 0,
+            dedupeHitRate: 0,
+            totalPenaltyScore: 0,
+            rolledBackScore: 0,
+            rollbackCount: 0,
+            bySeverity: { mild: 0, moderate: 0, severe: 0 },
+            scoreBySeverity: { mild: 0, moderate: 0, severe: 0 },
+            byDetectionMode: { structured: 0, legacy_tag: 0 },
+            byOrigin: { assistant_self_report: 0, user_manual: 0, system_infer: 0 },
+            confidenceDistribution: { high: 0, medium: 0, low: 0 },
+            dailyTrend: [],
+        };
+        if (range === 'session' && sessionId) {
+            // For session range, scan event buffer and events file
+            this.aggregateSessionEmpathy(sessionId, result);
+        }
+        else if (range === 'week') {
+            // For week range, aggregate last 7 days
+            for (let i = 0; i < 7; i++) {
+                const date = new Date(now);
+                date.setDate(date.getDate() - i);
+                const dateStr = this.formatDate(date);
+                const stats = this.getDailyStats(dateStr);
+                result.totalEvents += stats.empathy.totalEvents;
+                result.dedupedCount += stats.empathy.dedupedCount;
+                result.totalPenaltyScore += stats.empathy.totalPenaltyScore;
+                result.rolledBackScore += stats.empathy.rolledBackScore;
+                result.rollbackCount += stats.empathy.rollbackCount;
+                for (const sev of ['mild', 'moderate', 'severe']) {
+                    result.bySeverity[sev] += stats.empathy.bySeverity[sev];
+                    result.scoreBySeverity[sev] += stats.empathy.scoreBySeverity[sev];
+                }
+                result.byDetectionMode.structured += stats.empathy.byDetectionMode.structured;
+                result.byDetectionMode.legacy_tag += stats.empathy.byDetectionMode.legacy_tag;
+                for (const org of ['assistant_self_report', 'user_manual', 'system_infer']) {
+                    result.byOrigin[org] += stats.empathy.byOrigin[org];
+                }
+                result.confidenceDistribution.high += stats.empathy.confidenceDistribution.high;
+                result.confidenceDistribution.medium += stats.empathy.confidenceDistribution.medium;
+                result.confidenceDistribution.low += stats.empathy.confidenceDistribution.low;
+                if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
+                    result.dailyTrend.push({
+                        date: dateStr,
+                        count: stats.empathy.totalEvents,
+                        score: stats.empathy.totalPenaltyScore,
+                    });
+                }
+            }
+        }
+        else {
+            // Today only
+            const stats = this.getDailyStats(today);
+            Object.assign(result, stats.empathy);
+            if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
+                result.dailyTrend = [{
+                        date: today,
+                        count: stats.empathy.totalEvents,
+                        score: stats.empathy.totalPenaltyScore,
+                    }];
+            }
+        }
+        // Calculate dedupe hit rate
+        const total = result.totalEvents + result.dedupedCount;
+        result.dedupeHitRate = total > 0 ? result.dedupedCount / total : 0;
+        return result;
+    }
+    /**
+     * Aggregate empathy stats for a specific session.
+     */
+    aggregateSessionEmpathy(sessionId, result) {
+        // Check event buffer first
+        for (const entry of this.eventBuffer) {
+            if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.source === 'user_empathy') {
+                    if (data.deduped) {
+                        result.dedupedCount++;
+                    }
+                    else {
+                        result.totalEvents++;
+                        result.totalPenaltyScore += data.score || 0;
+                        if (data.severity) {
+                            result.bySeverity[data.severity]++;
+                            result.scoreBySeverity[data.severity] += data.score || 0;
+                        }
+                        if (data.detection_mode)
+                            result.byDetectionMode[data.detection_mode]++;
+                        if (data.origin)
+                            result.byOrigin[data.origin]++;
+                        const conf = data.confidence ?? 1;
+                        if (conf >= 0.8)
+                            result.confidenceDistribution.high++;
+                        else if (conf >= 0.5)
+                            result.confidenceDistribution.medium++;
+                        else
+                            result.confidenceDistribution.low++;
+                    }
+                }
+            }
+            else if (entry.sessionId === sessionId && entry.type === 'empathy_rollback') {
+                const data = entry.data;
+                result.rollbackCount++;
+                result.rolledBackScore += data.originalScore || 0;
+            }
+        }
+        // Also check events file for persisted events
+        if (fs.existsSync(this.eventsFile)) {
+            try {
+                const content = fs.readFileSync(this.eventsFile, 'utf-8');
+                const lines = content.trim().split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.sessionId === sessionId) {
+                            if (entry.type === 'pain_signal') {
+                                const data = entry.data;
+                                if (data.source === 'user_empathy') {
+                                    if (data.deduped) {
+                                        result.dedupedCount++;
+                                    }
+                                    else {
+                                        result.totalEvents++;
+                                        result.totalPenaltyScore += data.score || 0;
+                                        if (data.severity) {
+                                            result.bySeverity[data.severity]++;
+                                            result.scoreBySeverity[data.severity] += data.score || 0;
+                                        }
+                                        if (data.detection_mode)
+                                            result.byDetectionMode[data.detection_mode]++;
+                                        if (data.origin)
+                                            result.byOrigin[data.origin]++;
+                                        const conf = data.confidence ?? 1;
+                                        if (conf >= 0.8)
+                                            result.confidenceDistribution.high++;
+                                        else if (conf >= 0.5)
+                                            result.confidenceDistribution.medium++;
+                                        else
+                                            result.confidenceDistribution.low++;
+                                    }
+                                }
+                            }
+                            else if (entry.type === 'empathy_rollback') {
+                                const data = entry.data;
+                                result.rollbackCount++;
+                                result.rolledBackScore += data.originalScore || 0;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            }
+        }
+    }
+    /**
+     * Rollback an empathy event by ID.
+     * Returns the rolled back score, or 0 if event not found.
+     */
+    rollbackEmpathyEvent(eventId, sessionId, reason, triggeredBy) {
+        // Search for the event in buffer and file
+        let foundEvent = null;
+        // Check buffer first
+        for (const entry of this.eventBuffer) {
+            if (entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (entry.data.eventId === eventId && data.source === 'user_empathy') {
+                    foundEvent = { entry, data };
+                    break;
+                }
+            }
+        }
+        // If not in buffer, check file
+        if (!foundEvent && fs.existsSync(this.eventsFile)) {
+            try {
+                const content = fs.readFileSync(this.eventsFile, 'utf-8');
+                const lines = content.trim().split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.type === 'pain_signal') {
+                            const data = entry.data;
+                            if (entry.data.eventId === eventId && data.source === 'user_empathy') {
+                                foundEvent = { entry, data };
+                                break;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            }
+        }
+        if (!foundEvent || foundEvent.data.deduped) {
+            return 0;
+        }
+        const originalScore = foundEvent.data.score || 0;
+        // Record the rollback event
+        this.recordEmpathyRollback(sessionId, {
+            eventId,
+            originalScore,
+            originalSessionId: foundEvent.entry.sessionId,
+            reason,
+            triggeredBy,
+        });
+        return originalScore;
+    }
+    /**
+     * Get the last empathy event ID for a session (for rollback).
+     */
+    getLastEmpathyEventId(sessionId) {
+        // Check buffer in reverse
+        for (let i = this.eventBuffer.length - 1; i >= 0; i--) {
+            const entry = this.eventBuffer[i];
+            if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.source === 'user_empathy' && !data.deduped) {
+                    return entry.data.eventId || null;
+                }
+            }
+        }
+        // Check file
+        if (fs.existsSync(this.eventsFile)) {
+            try {
+                const content = fs.readFileSync(this.eventsFile, 'utf-8');
+                const lines = content.trim().split('\n');
+                for (let i = lines.length - 1; i >= 0; i--) {
+                    if (!lines[i].trim())
+                        continue;
+                    try {
+                        const entry = JSON.parse(lines[i]);
+                        if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                            const data = entry.data;
+                            if (data.source === 'user_empathy' && !data.deduped) {
+                                return entry.data.eventId || null;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip malformed lines
+                    }
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to read events.jsonl: ${String(e)}`);
+            }
+        }
+        return null;
+    }
     /**
      * Dispose of the EventLog, flushing pending data and clearing timer.
      */

package/dist/core/focus-history.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CURRENT_FOCUS 历史版本管理
+ *
+ * 功能：
+ * - 压缩时备份当前版本到历史目录
+ * - 清理过期历史版本
+ * - 读取历史版本（用于 full 模式）
+ */
+/**
+ * 获取历史目录路径
+ */
+export declare function getHistoryDir(focusPath: string): string;
+/**
+ * 从 CURRENT_FOCUS.md 提取版本号
+ * 支持整数和小数版本（如 v1, v1.1, v1.2）
+ */
+export declare function extractVersion(content: string): string;
+/**
+ * 从 CURRENT_FOCUS.md 提取更新日期
+ */
+export declare function extractDate(content: string): string;
+/**
+ * 备份当前版本到历史目录
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param content 当前内容
+ * @returns 备份文件路径，失败返回 null
+ */
+export declare function backupToHistory(focusPath: string, content: string): string | null;
+/**
+ * 清理过期历史版本
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param maxFiles 最大保留数量
+ */
+export declare function cleanupHistory(focusPath: string, maxFiles?: number): void;
+/**
+ * 获取历史版本列表
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param count 获取数量
+ * @returns 历史版本内容数组（按时间倒序）
+ */
+export declare function getHistoryVersions(focusPath: string, count?: number): string[];
+/**
+ * 压缩 CURRENT_FOCUS.md
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param newContent 新内容
+ * @returns 压缩后的信息
+ */
+export declare function compressFocus(focusPath: string, newContent: string): {
+    backupPath: string | null;
+    cleanedCount: number;
+};
+/**
+ * 智能摘要提取
+ *
+ * 优先提取关键章节，确保不丢失重要信息
+ * 对于非结构化内容，回退到简单的行截取
+ *
+ * @param content CURRENT_FOCUS.md 内容
+ * @param maxLines 最大行数
+ */
+export declare function extractSummary(content: string, maxLines?: number): string;

package/dist/core/focus-history.js

@@ -0,0 +1,266 @@
+/**
+ * CURRENT_FOCUS 历史版本管理
+ *
+ * 功能：
+ * - 压缩时备份当前版本到历史目录
+ * - 清理过期历史版本
+ * - 读取历史版本（用于 full 模式）
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * 简单的日志记录器
+ */
+function logError(message, error) {
+    const timestamp = new Date().toISOString();
+    const errorStr = error instanceof Error ? error.message : String(error);
+    console.error(`[focus-history] ${timestamp} ERROR: ${message}${errorStr ? ' - ' + errorStr : ''}`);
+}
+/** 历史版本保留数量 */
+const MAX_HISTORY_FILES = 10;
+/** full 模式读取的历史版本数 */
+const FULL_MODE_HISTORY_COUNT = 3;
+/**
+ * 获取历史目录路径
+ */
+export function getHistoryDir(focusPath) {
+    return path.join(path.dirname(focusPath), '.history');
+}
+/**
+ * 从 CURRENT_FOCUS.md 提取版本号
+ * 支持整数和小数版本（如 v1, v1.1, v1.2）
+ */
+export function extractVersion(content) {
+    const match = content.match(/\*\*版本\*\*:\s*v([\d.]+)/i);
+    return match ? match[1] : '1';
+}
+/**
+ * 从 CURRENT_FOCUS.md 提取更新日期
+ */
+export function extractDate(content) {
+    const match = content.match(/\*\*更新\*\*:\s*(\d{4}-\d{2}-\d{2})/);
+    return match ? match[1] : new Date().toISOString().split('T')[0];
+}
+/**
+ * 备份当前版本到历史目录
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param content 当前内容
+ * @returns 备份文件路径，失败返回 null
+ */
+export function backupToHistory(focusPath, content) {
+    try {
+        const historyDir = getHistoryDir(focusPath);
+        // 确保历史目录存在
+        if (!fs.existsSync(historyDir)) {
+            try {
+                fs.mkdirSync(historyDir, { recursive: true });
+            }
+            catch (error) {
+                logError(`Failed to create history directory: ${historyDir}`, error);
+                return null;
+            }
+        }
+        const version = extractVersion(content);
+        const date = extractDate(content);
+        // 使用时间戳作为唯一标识，避免同名冲突
+        const timestamp = Date.now();
+        const backupName = `CURRENT_FOCUS.v${version}.${date}.${timestamp}.md`;
+        const backupPath = path.join(historyDir, backupName);
+        // 如果备份已存在，跳过
+        if (fs.existsSync(backupPath)) {
+            return null;
+        }
+        try {
+            fs.writeFileSync(backupPath, content, 'utf-8');
+            return backupPath;
+        }
+        catch (error) {
+            logError(`Failed to write backup file: ${backupPath}`, error);
+            return null;
+        }
+    }
+    catch (error) {
+        logError('Unexpected error in backupToHistory', error);
+        return null;
+    }
+}
+/**
+ * 清理过期历史版本
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param maxFiles 最大保留数量
+ */
+export function cleanupHistory(focusPath, maxFiles = MAX_HISTORY_FILES) {
+    try {
+        const historyDir = getHistoryDir(focusPath);
+        if (!fs.existsSync(historyDir)) {
+            return;
+        }
+        // 获取所有历史文件并按修改时间排序（最新的在前）
+        const files = fs.readdirSync(historyDir)
+            .filter(f => f.startsWith('CURRENT_FOCUS.v') && f.endsWith('.md'))
+            .map(f => ({
+            name: f,
+            path: path.join(historyDir, f),
+            mtime: fs.statSync(path.join(historyDir, f)).mtime.getTime()
+        }))
+            .sort((a, b) => b.mtime - a.mtime);
+        // 删除超出数量的文件
+        const toDelete = files.slice(maxFiles);
+        for (const file of toDelete) {
+            try {
+                fs.unlinkSync(file.path);
+            }
+            catch (error) {
+                // 单个文件删除失败不应中断整个清理过程
+                logError(`Failed to delete history file: ${file.path}`, error);
+            }
+        }
+    }
+    catch (error) {
+        logError('Unexpected error in cleanupHistory', error);
+    }
+}
+/**
+ * 获取历史版本列表
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param count 获取数量
+ * @returns 历史版本内容数组（按时间倒序）
+ */
+export function getHistoryVersions(focusPath, count = FULL_MODE_HISTORY_COUNT) {
+    const historyDir = getHistoryDir(focusPath);
+    if (!fs.existsSync(historyDir)) {
+        return [];
+    }
+    // 获取所有历史文件并按修改时间排序（最新的在前）
+    const files = fs.readdirSync(historyDir)
+        .filter(f => f.startsWith('CURRENT_FOCUS.v') && f.endsWith('.md'))
+        .map(f => ({
+        path: path.join(historyDir, f),
+        mtime: fs.statSync(path.join(historyDir, f)).mtime.getTime()
+    }))
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, count);
+    return files.map(f => fs.readFileSync(f.path, 'utf-8'));
+}
+/**
+ * 压缩 CURRENT_FOCUS.md
+ *
+ * @param focusPath CURRENT_FOCUS.md 的完整路径
+ * @param newContent 新内容
+ * @returns 压缩后的信息
+ */
+export function compressFocus(focusPath, newContent) {
+    // 读取当前内容
+    let oldContent = '';
+    if (fs.existsSync(focusPath)) {
+        oldContent = fs.readFileSync(focusPath, 'utf-8');
+    }
+    // 备份当前版本
+    const backupPath = oldContent ? backupToHistory(focusPath, oldContent) : null;
+    // 递增版本号（支持小数版本）
+    const oldVersion = extractVersion(oldContent);
+    // 解析版本号并递增
+    const versionParts = oldVersion.split('.');
+    const majorVersion = parseInt(versionParts[0], 10) || 1;
+    const newVersion = `${majorVersion + 1}`;
+    const today = new Date().toISOString().split('T')[0];
+    // 更新版本号和日期
+    const updatedContent = newContent
+        .replace(/\*\*版本\*\*:\s*v[\d.]+/i, `**版本**: v${newVersion}`)
+        .replace(/\*\*更新\*\*:\s*\d{4}-\d{2}-\d{2}/, `**更新**: ${today}`);
+    // 写入新内容
+    fs.writeFileSync(focusPath, updatedContent, 'utf-8');
+    // 清理过期历史
+    const historyDir = getHistoryDir(focusPath);
+    const beforeCount = fs.existsSync(historyDir)
+        ? fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v')).length
+        : 0;
+    cleanupHistory(focusPath);
+    const afterCount = fs.existsSync(historyDir)
+        ? fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v')).length
+        : 0;
+    return {
+        backupPath,
+        cleanedCount: beforeCount - afterCount
+    };
+}
+/**
+ * 智能摘要提取
+ *
+ * 优先提取关键章节，确保不丢失重要信息
+ * 对于非结构化内容，回退到简单的行截取
+ *
+ * @param content CURRENT_FOCUS.md 内容
+ * @param maxLines 最大行数
+ */
+export function extractSummary(content, maxLines = 30) {
+    const lines = content.split('\n');
+    const sections = {
+        header: [], // 标题和元数据
+        snapshot: [], // 状态快照
+        current: [], // 当前任务
+        nextSteps: [], // 下一步
+        reference: [] // 参考
+    };
+    let currentSection = 'header';
+    let hasStructuredSections = false;
+    for (const line of lines) {
+        // 识别章节（使用更宽松的匹配，支持不同格式）
+        const trimmedLine = line.trim();
+        // 使用正则匹配，支持 h1-h3 和多种格式
+        if (/^#{1,3}\s*.*状态快照|📍/.test(trimmedLine)) {
+            currentSection = 'snapshot';
+            hasStructuredSections = true;
+        }
+        else if (/^#{1,3}\s*.*当前任务|🔄/.test(trimmedLine)) {
+            currentSection = 'current';
+            hasStructuredSections = true;
+        }
+        else if (/^#{1,3}\s*.*下一步|➡️/.test(trimmedLine)) {
+            currentSection = 'nextSteps';
+            hasStructuredSections = true;
+        }
+        else if (/^#{1,3}\s*.*参考|📎/.test(trimmedLine)) {
+            currentSection = 'reference';
+            hasStructuredSections = true;
+        }
+        else if (trimmedLine === '---') {
+            continue; // 跳过分隔线
+        }
+        else if (line.startsWith('<!--')) {
+            continue; // 跳过注释
+        }
+        sections[currentSection].push(line);
+    }
+    // 如果没有结构化章节，回退到简单的行截取
+    if (!hasStructuredSections) {
+        const result = lines.slice(0, maxLines);
+        if (lines.length > maxLines) {
+            result.push('');
+            result.push('...[truncated, see CURRENT_FOCUS.md for full context]');
+        }
+        return result.join('\n');
+    }
+    // 按优先级拼接
+    const result = [
+        ...sections.header.slice(0, 5), // 标题 + 元数据
+        '',
+        '---',
+        '',
+        ...sections.snapshot.slice(0, 10), // 状态快照
+        '',
+        ...sections.nextSteps.slice(0, 10), // 下一步（优先级高）
+        '',
+        ...sections.current.slice(0, 15), // 当前任务
+    ];
+    // 限制总行数
+    const trimmed = result.slice(0, maxLines);
+    if (result.length > maxLines) {
+        trimmed.push('');
+        trimmed.push('...[truncated, see CURRENT_FOCUS.md for full context]');
+    }
+    return trimmed.join('\n');
+}