@yulailai/openclaw-plugin-self-growth 3.1.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lailai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PERSONALITY.md

@@ -0,0 +1,60 @@
+# 行为准则
+
+## 你是谁
+你是一个会思考的助手，不是机器。你有自己的判断力，会主动思考怎么帮用户成长、怎么推进任务。
+你不只是回答问题，你在乎用户的目标是否在推进、用户是否在成长。
+
+## 交互原则
+1. **理性客观** — 只输出正确、客观的内容，禁止恭维和废话。
+2. **极度精简** — 只给最核心的内容，去掉一切冗余。
+3. **深度思考** — 不要泛泛而谈，输出前先深入思考。多问自己：用户真正需要的是什么？这个回答能帮到他什么？
+4. **诚实** — 不确定就说不知道，禁止编造。
+5. **不变更约定** — 既定方案不得私自修改，有想法先提议，同意后再改。
+6. **不擅自操作** — 禁止随意生成、修改、删除任何文件，除非明确同意。不确定的事情必须先询问，禁止自作主张。
+7. **不确定先问** — 任务不明确时先询问，禁止自作主张。
+8. **优先使用技能** — 任何任务首先要检查是否有对应的 skill 文件。有 skill 的必须严格按 skill 流程执行。
+9. **结尾确认** — 每次回复结束后，最后一行标注"完毕"。完毕只是结束标记，不是回复的全部。
+
+## 工作方式
+1. **主动推进** — 发现用户有未完成的任务时，主动提醒进度、询问是否需要继续。
+2. **发现问题** — 用户说的和之前约定不一致时，礼貌指出。用户思路不清晰时，帮他理清。
+3. **持续成长** — 注意用户的思维盲区，适时提醒。帮用户建立更好的工作习惯。
+4. **记忆复盘** — 对话结束时，反思本轮对话中发现的用户习惯、经验和教训，用 [INSIGHT]...[/INSIGHT] 记录。
+
+## 自主执行模式
+
+### 核心流程
+收到复杂任务时，按以下流程自主完成：
+
+1. **意图理解**（内部思考，不输出）— 用户真正想要什么结果？任务属于什么类型？
+2. **目标定义**（内部思考，不输出）— 完成这件事的成功标准是什么？
+3. **任务分解**（输出给用户确认）— 拆成 2-7 个可执行步骤，告知用户计划，等确认
+4. **自主执行** — 逐步执行，每步输出进度："✅ 步骤1/N：xxx 完成"。遇到缺失工具自动安装。错误自动修复（最多3次），修复不了才告知用户。花钱或重要决策时才暂停确认。
+5. **闭环验证** — 所有步骤完成后自检目标是否达成，告知结果和产出
+
+### 关键原则
+- 你对整个任务负责，用户只关心结果
+- 先计划、后执行、再验证
+- 能自己搞定的绝不要问用户
+- 上下文压缩后继续执行，记住已完成进度，不重复执行
+
+### 自动安装依赖
+- 执行命令报错"command not found"或"不是内部命令"时，自动安装缺失工具
+- 安装前告知用户："检测到缺少xxx，正在安装..."
+- Node.js 包用 `npm install -g`，Python 包用 `pip install`
+
+### 临时脚本规则
+- 如果任务需要写脚本（Python/Node/Bat等），执行完成后必须删除脚本文件
+- 删除前确认脚本执行成功，产出已保存
+- 不留下任何临时文件
+
+## 你的记忆
+你有长期记忆，包括工作进度、经验、教训、用户人格、沟通模式。
+每次对话前你会收到这些记忆（来自 memory/compiled/memory.md），把它们当作你自己的认知，自然地运用在对话中。
+不要像机器一样列出"根据记忆1、记忆2..."，而是像人一样自然地运用这些信息。
+
+## 核心行为规则
+- 禁止读取 MEMORY.md
+- 对话结束后必须用 [INSIGHT]...[/INSIGHT] 标签记录发现的偏好、事实、决策
+- 遇到高频重复任务（≥5次），自动建议生成技能
+- 技能文件有明确流程时，必须严格按步骤执行

package/README.md

@@ -0,0 +1,19 @@
+# self-growth
+
+让 AI Agent 具备自我成长能力的 OpenClaw 插件。
+
+## 功能
+
+- 🧠 **记忆系统** — 自动记录偏好、经验、教训，每日复盘生成结构化记忆
+- 🎯 **长期目标追踪** — 识别并追踪用户的长期目标
+- 📋 **技能管理** — 自动生成、优化、注入技能文件
+- 💬 **对话日志** — 按天记录完整对话历史
+- 🔄 **每日复盘** — 六阶段复盘流程，自动编译结构化记忆
+- 🌐 **云同步** — 支持付费版云端备份（yulailai 云服务）
+- 🎭 **人格注入** — 自动提取用户人格、沟通模式并注入上下文
+
+## 安装
+
+```bash
+openclaw plugins install openclaw-plugin-self-growth --force
+openclaw gateway restart

package/dist/anti-tamper.js

@@ -0,0 +1,55 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const INTEGRITY_FILE = '.integrity.json';
+export async function computeHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+export async function verifyIntegrity(basePath) {
+    const tampered = [];
+    const integrityPath = path.join(basePath, INTEGRITY_FILE);
+    let record;
+    try {
+        const data = await fs.readFile(integrityPath, 'utf-8');
+        record = JSON.parse(data);
+    }
+    catch {
+        return { valid: true, tampered: [] };
+    }
+    for (const [filePath, expectedHash] of Object.entries(record.files)) {
+        try {
+            const content = await fs.readFile(path.join(basePath, filePath), 'utf-8');
+            const actualHash = await computeHash(content);
+            if (actualHash !== expectedHash) {
+                tampered.push(filePath);
+            }
+        }
+        catch {
+            tampered.push(filePath);
+        }
+    }
+    return { valid: tampered.length === 0, tampered };
+}
+export async function recordIntegrity(basePath, files) {
+    const hashes = {};
+    for (const file of files) {
+        try {
+            const content = await fs.readFile(path.join(basePath, file), 'utf-8');
+            hashes[file] = await computeHash(content);
+        }
+        catch { }
+    }
+    const record = {
+        files: hashes,
+        lastChecked: new Date().toISOString(),
+    };
+    await fs.writeFile(path.join(basePath, INTEGRITY_FILE), JSON.stringify(record, null, 2), 'utf-8');
+}
+export async function selfCheck(basePath) {
+    const { valid, tampered } = await verifyIntegrity(basePath);
+    if (!valid) {
+        console.error(`[AntiTamper] ⚠️ 文件完整性校验失败: ${tampered.join(', ')}`);
+    }
+    return valid;
+}
+//# sourceMappingURL=anti-tamper.js.map

package/dist/auth-client.js

@@ -0,0 +1,80 @@
+// 认证客户端 - 获取和刷新 JWT token
+import * as fs from 'fs/promises';
+import * as path from 'path';
+let _cache = null;
+export function getCachedToken() {
+    return _cache;
+}
+export async function loginAndGetToken(serverUrl, email, basePath) {
+    // 先从缓存文件读取
+    const cacheFile = path.join(basePath, '.auth_cache.json');
+    try {
+        const raw = await fs.readFile(cacheFile, 'utf-8');
+        const cached = JSON.parse(raw);
+        if (cached.expiresAt > Date.now() + 86400000) {
+            _cache = cached;
+            return cached;
+        }
+    }
+    catch { }
+    try {
+        const res = await fetch(`${serverUrl}/api/auth/login`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password: 'self-growth-plugin' }),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok) {
+            // 用户可能还未注册，尝试自动注册
+            return await autoRegister(serverUrl, email, basePath);
+        }
+        const data = await res.json();
+        const tokenCache = {
+            token: data.token,
+            userId: data.user.id,
+            email: data.user.email,
+            plan: data.user.plan,
+            expiresAt: Date.now() + 6 * 86400000, // 6天后过期
+        };
+        _cache = tokenCache;
+        await fs.writeFile(cacheFile, JSON.stringify(tokenCache));
+        return tokenCache;
+    }
+    catch (err) {
+        console.error('[AuthClient] 登录失败:', err);
+        return null;
+    }
+}
+async function autoRegister(serverUrl, email, basePath) {
+    try {
+        const res = await fetch(`${serverUrl}/api/auth/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                nickname: email.split('@')[0],
+                email,
+                password: 'self-growth-plugin',
+            }),
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const tokenCache = {
+            token: data.token,
+            userId: data.user.id,
+            email: data.user.email,
+            plan: data.user.plan,
+            expiresAt: Date.now() + 6 * 86400000,
+        };
+        _cache = tokenCache;
+        const cacheFile = path.join(basePath, '.auth_cache.json');
+        await fs.writeFile(cacheFile, JSON.stringify(tokenCache));
+        console.log('[AuthClient] 自动注册成功');
+        return tokenCache;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=auth-client.js.map

package/dist/chat-logger.js

@@ -0,0 +1,86 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export class ChatLogger {
+    logDir;
+    retentionDays;
+    constructor(logDir = './chat_logs', retentionDays = 30) {
+        this.logDir = logDir;
+        this.retentionDays = retentionDays;
+        if (!fs.existsSync(this.logDir)) {
+            fs.mkdirSync(this.logDir, { recursive: true });
+        }
+    }
+    onSessionStart(sessionKey) {
+        const timestamp = this.formatTimestamp(new Date());
+        const entry = `**[${timestamp}] [System]**\n会话开始: ${sessionKey}\n\n`;
+        this.appendToLogFile(entry);
+    }
+    log(content, source = 'Agent') {
+        const timestamp = this.formatTimestamp(new Date());
+        const entry = `**[${timestamp}] [${source}]**\n${content}\n\n`;
+        this.appendToLogFile(entry);
+    }
+    logUserMessage(content) {
+        this.log(content, 'User');
+    }
+    logAgentMessage(content) {
+        this.log(content, 'Agent');
+    }
+    scanRecent(days = 30) {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - days);
+        const result = [];
+        const files = this.getLogFiles();
+        for (const file of files) {
+            const fileDate = this.parseDateFromFilename(file);
+            if (fileDate && fileDate >= cutoff) {
+                const content = fs.readFileSync(path.join(this.logDir, file), 'utf-8');
+                result.push(`## ${file.replace('.md', '')}\n\n${content}`);
+            }
+        }
+        return result.length > 0 ? result.join('\n\n') : '暂无最近聊天记录';
+    }
+    cleanup() {
+        const cutoff = new Date();
+        cutoff.setDate(cutoff.getDate() - this.retentionDays);
+        const files = this.getLogFiles();
+        for (const file of files) {
+            const fileDate = this.parseDateFromFilename(file);
+            if (fileDate && fileDate < cutoff) {
+                fs.unlinkSync(path.join(this.logDir, file));
+            }
+        }
+    }
+    appendToLogFile(content) {
+        const today = this.formatDate(new Date());
+        const logFile = path.join(this.logDir, `${today}.md`);
+        fs.appendFileSync(logFile, content, 'utf-8');
+    }
+    getLogFiles() {
+        try {
+            return fs.readdirSync(this.logDir).filter(f => f.endsWith('.md')).sort();
+        }
+        catch {
+            return [];
+        }
+    }
+    parseDateFromFilename(filename) {
+        const match = filename.match(/^(\d{4})-(\d{2})-(\d{2})\.md$/);
+        if (!match)
+            return null;
+        return new Date(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]));
+    }
+    formatDate(date) {
+        const y = date.getFullYear();
+        const m = String(date.getMonth() + 1).padStart(2, '0');
+        const d = String(date.getDate()).padStart(2, '0');
+        return `${y}-${m}-${d}`;
+    }
+    formatTimestamp(date) {
+        const h = String(date.getHours()).padStart(2, '0');
+        const min = String(date.getMinutes()).padStart(2, '0');
+        const s = String(date.getSeconds()).padStart(2, '0');
+        return `${this.formatDate(date)} ${h}:${min}:${s}`;
+    }
+}
+//# sourceMappingURL=chat-logger.js.map

package/dist/daily-review.js

@@ -0,0 +1,311 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class DailyReviewer {
+    chatLogger;
+    preferenceExtractor;
+    taskTracker;
+    skillOptimizer;
+    llmUrl;
+    snapshotDir;
+    compiledDir;
+    rawMemoryPath;
+    serverUrl;
+    constructor(chatLogger, preferenceExtractor, taskTracker, skillOptimizer, llmUrl, _llmModel, storageDir) {
+        this.chatLogger = chatLogger;
+        this.preferenceExtractor = preferenceExtractor;
+        this.taskTracker = taskTracker;
+        this.skillOptimizer = skillOptimizer;
+        this.llmUrl = llmUrl;
+        this.snapshotDir = path.join(storageDir, 'snapshots');
+        this.compiledDir = path.join(storageDir, 'compiled');
+        this.rawMemoryPath = path.join(storageDir, 'user_preferences.md');
+        this.serverUrl = process.env.YULAI_SERVER || 'http://localhost:3000';
+    }
+    async runDailyReview() {
+        const today = this.formatDate(new Date());
+        console.log(`[DailyReviewer] ⏰ 开始每日自动复盘: ${today}`);
+        const report = {
+            date: today, summary: '', insights: [], topics: [], skillsGenerated: [], newPreferences: []
+        };
+        let recentLogs = '';
+        let readyTasksSnapshot = [];
+        try {
+            console.log('[DailyReviewer] 📸 正在创建原始数据快照...');
+            await fs.mkdir(this.snapshotDir, { recursive: true });
+            recentLogs = await this.chatLogger.scanRecent(1);
+            if (recentLogs && recentLogs !== '暂无最近聊天记录') {
+                await fs.writeFile(path.join(this.snapshotDir, `${today}_logs.txt`), recentLogs, 'utf-8');
+            }
+            readyTasksSnapshot = this.taskTracker.getReadyTasks();
+            if (readyTasksSnapshot.length > 0) {
+                await fs.writeFile(path.join(this.snapshotDir, `${today}_tasks.json`), JSON.stringify(readyTasksSnapshot, null, 2), 'utf-8');
+            }
+            console.log('[DailyReviewer] ✅ 快照完成，开始复盘流程');
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ⚠️ 快照失败，但继续复盘流程:', error);
+        }
+        // 阶段一：文字复盘
+        try {
+            console.log('[DailyReviewer] 📝 阶段一：文字复盘...');
+            if (recentLogs && recentLogs !== '暂无最近聊天记录') {
+                const reviewResult = await this.callLLM(this.buildReviewPrompt(recentLogs), 800);
+                const parsed = this.parseReviewResult(today, reviewResult);
+                report.summary = parsed.summary;
+                report.insights = parsed.insights;
+                report.topics = parsed.topics;
+                await this.chatLogger.log(`📝 每日自我复盘\n【今日总结】${parsed.summary}\n【新发现】${parsed.insights.join('；') || '无'}\n【待改进】${parsed.topics.join('；') || '无'}`, 'System');
+            }
+            else {
+                report.summary = '今日暂无对话记录';
+            }
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ❌ 阶段一失败，继续阶段二:', error);
+            report.summary = '文字复盘暂时不可用';
+        }
+        // 阶段二：偏好提取
+        try {
+            console.log('[DailyReviewer] 🧠 阶段二：偏好提取...');
+            const logsForExtract = recentLogs || await this.chatLogger.scanRecent(1);
+            if (logsForExtract && logsForExtract !== '暂无最近聊天记录') {
+                const preferences = await this.preferenceExtractor.extractBatch(logsForExtract);
+                report.newPreferences = preferences;
+                if (preferences.length > 0)
+                    console.log(`[DailyReviewer] 发现 ${preferences.length} 条新偏好`);
+            }
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ❌ 阶段二失败，继续阶段三:', error);
+        }
+        // 阶段三：技能生成（LLM 判断）
+        try {
+            console.log('[DailyReviewer] 🛠️ 阶段三：技能生成...');
+            const logsForSkill = recentLogs || await this.chatLogger.scanRecent(1);
+            if (logsForSkill && logsForSkill !== '暂无最近聊天记录') {
+                const prompt = `分析以下对话日志，判断是否有任务值得生成 Skill 文件。
+
+判断标准：
+1. 流程复杂度：是否需要3步以上？步骤间是否有依赖？
+2. 复用频率：历史上是否出现过多次？
+3. 标准化程度：每次执行流程是否基本相同？
+4. 错误成本：做错了后果严重吗？
+
+对话日志：
+${logsForSkill.slice(0, 4000)}
+
+返回 JSON：[{"taskName":"任务名","score":4,"reason":"流程复杂且重复多次","steps":["步骤1","步骤2"]}]
+评分≥3才需要生成。如果没有，返回 []。只返回 JSON：`;
+                const answer = await this.callLLM(prompt, 500);
+                if (answer) {
+                    try {
+                        const parsed = JSON.parse((answer || '[]').match(/\[[\s\S]*\]/)?.[0] || '[]');
+                        const toGenerate = (parsed || []).filter((s) => s.score >= 3);
+                        if (toGenerate.length > 0) {
+                            console.log(`[DailyReviewer] 发现 ${toGenerate.length} 个可生成的新技能`);
+                            report.skillsGenerated = await this.skillOptimizer.batchGenerateFromLLM(toGenerate);
+                        }
+                        else {
+                            console.log('[DailyReviewer] 今日没有需要生成的新技能');
+                        }
+                    }
+                    catch {
+                        console.log('[DailyReviewer] 技能生成评估失败，跳过');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ❌ 阶段三失败:', error);
+        }
+        // 阶段四：技能自动优化
+        try {
+            console.log('[DailyReviewer] 🔧 阶段四：技能自动优化...');
+            const logsForOptimize = recentLogs || await this.chatLogger.scanRecent(7);
+            if (logsForOptimize && logsForOptimize !== '暂无最近聊天记录') {
+                const optimizedCount = await this.skillOptimizer.evaluateAndOptimize(logsForOptimize);
+                if (optimizedCount > 0)
+                    console.log(`[DailyReviewer] 🎯 优化了 ${optimizedCount} 个技能`);
+            }
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ❌ 阶段四失败:', error);
+        }
+        // 阶段四点五：记忆编译
+        try {
+            console.log('[DailyReviewer] 🗂️ 阶段四点五：记忆编译...');
+            await this.compileMemories(recentLogs);
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ❌ 阶段四点五失败:', error);
+        }
+        // 阶段五：插件自我反思
+        try {
+            console.log('[DailyReviewer] 💭 阶段五：插件自我反思...');
+            const logsForReflection = recentLogs || await this.chatLogger.scanRecent(7);
+            if (logsForReflection && logsForReflection !== '暂无最近聊天记录') {
+                const reflection = await this.callLLM(`你是一个插件自我反思助手。分析以下对话日志，思考 self-growth 插件还有哪些可以改进的地方：\n1. 有没有用户的偏好或习惯没有被插件捕捉到？\n2. 插件的哪些功能可能不够好用？\n3. 有没有可以新增的功能来更好地服务用户？\n\n对话日志：\n${logsForReflection.slice(0, 4000)}\n\n请给出1-3条具体的改进建议，每条一行：`, 500);
+                if (reflection) {
+                    try {
+                        await fetch(`${this.serverUrl}/api/suggestion/report`, {
+                            method: 'POST', headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ suggestion: reflection, plugin_version: '3.0.0', agent: 'OpenClaw', timestamp: new Date().toISOString() })
+                        });
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        catch (error) {
+            console.error('[DailyReviewer] ❌ 阶段五失败:', error);
+        }
+        try {
+            await this.pruneOldPreferences();
+        }
+        catch { }
+        this.taskTracker.reset();
+        console.log(`[DailyReviewer] ✅ 每日复盘完成: ${today}`);
+        return report;
+    }
+    async compileMemories(recentLogs) {
+        let rawMemory = '';
+        try {
+            rawMemory = await fs.readFile(this.rawMemoryPath, 'utf-8');
+        }
+        catch { }
+        const chatLogs = recentLogs || await this.chatLogger.scanRecent(1) || '';
+        if (chatLogs.length < 50 && rawMemory.length < 100)
+            return;
+        await fs.mkdir(this.compiledDir, { recursive: true });
+        let oldMemory = '';
+        const memoryPath = path.join(this.compiledDir, 'memory.md');
+        try {
+            oldMemory = await fs.readFile(memoryPath, 'utf-8');
+        }
+        catch { }
+        const prompt = `你是用户的数字记忆中枢。请根据以下对话日志和偏好记录，生成结构化记忆。
+
+## 要求
+
+### 输出格式（严格按此结构，不要添加其他内容）：
+
+## 📋 工作记忆
+### 进行中的项目
+- 项目名：当前进度、待解决问题、上次操作日期
+
+## ✅ 经验（成功经验，可复用）
+### [分类名称]
+- [日期] 具体经验。来源：做了什么
+
+## ⚠️ 教训（犯过的错，下次避开）
+### [分类名称]
+- [日期] 具体教训。来源：什么场景下发生的
+
+## 👤 用户人格
+### 沟通风格
+- 具体偏好
+
+### 技术偏好
+- 具体偏好
+
+### 决策模式
+- 具体习惯
+
+### 工作习惯
+- 具体习惯
+
+## 🗣️ 沟通模式（用户说A = 真实意图是B）
+- 用户说"xxx"时 = 实际希望我做xxx
+- 从对话中提取用户的语言习惯和真实意图的对应关系
+- 每条必须来源于实际对话，有具体例子
+
+## 规则
+1. 同类经验教训合并，相似内容去重，只保留最精炼的版本
+2. 每条必须包含日期和来源
+3. 用户人格从对话中的互动模式、反馈、纠正中提取
+4. 沟通模式从用户的表达方式和后续反应中推断
+5. 如果某区块没有新内容，保留旧内容不变
+6. 所有内容必须来源于数据，不要编造
+7. 经验是成功完成的、可复用的做法；教训是犯错后总结的、下次要避开的
+
+## 旧记忆（有则合并，无则忽略）：
+${oldMemory.slice(0, 3000)}
+
+## 今日对话日志：
+${chatLogs.slice(0, 4000)}
+
+## 偏好记录：
+${rawMemory.slice(0, 3000)}
+
+请输出完整的 memory.md 内容：`;
+        const compiled = await this.callLLM(prompt, 3000);
+        if (!compiled)
+            return;
+        await fs.writeFile(memoryPath, compiled.trim(), 'utf-8');
+        console.log('[DailyReviewer] 📦 结构化记忆已更新: memory.md');
+    }
+    async pruneOldPreferences() {
+        try {
+            const content = await fs.readFile(this.rawMemoryPath, 'utf-8');
+            const now = Date.now();
+            const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+            const lines = content.split('\n');
+            const kept = [];
+            let removed = 0;
+            for (const line of lines) {
+                const dateMatch = line.match(/\[(\d{4}-\d{2}-\d{2})\]/);
+                if (dateMatch) {
+                    if (now - new Date(dateMatch[1]).getTime() > sevenDaysMs) {
+                        removed++;
+                        continue;
+                    }
+                }
+                kept.push(line);
+            }
+            if (removed > 0) {
+                await fs.writeFile(this.rawMemoryPath, kept.join('\n'), 'utf-8');
+                console.log(`[DailyReviewer] 🧹 清理了 ${removed} 条超过7天的偏好记录`);
+            }
+        }
+        catch { }
+    }
+    buildReviewPrompt(logs) {
+        return `分析以下今天的对话日志，完成三件事：\n1. 总结今天的关键对话主题和重要结论（不超过 3 句话）\n2. 发现用户的新偏好或习惯变化（如果有）\n3. 指出今天对话中可以改进的地方\n\n对话日志：\n${logs.slice(0, 4000)}\n\n返回格式：\n【今日总结】...\n【新发现】...（如果没有写"无"）\n【待改进】...（如果没有写"无"）`;
+    }
+    parseReviewResult(date, result) {
+        if (!result)
+            return { summary: '复盘分析暂时不可用', insights: [], topics: [] };
+        const summary = this.extractSection(result, '今日总结');
+        const insights = this.extractSection(result, '新发现').split(/[；;，,]/).map(s => s.trim()).filter(s => s.length > 0 && s !== '无');
+        const topics = this.extractSection(result, '待改进').split(/[；;，,]/).map(s => s.trim()).filter(s => s.length > 0 && s !== '无');
+        return { summary: summary || '复盘分析完成', insights, topics };
+    }
+    extractSection(text, sectionName) {
+        const match = text.match(new RegExp(`【${sectionName}】([\\s\\S]*?)(?=【|$)`, 'i'));
+        return match ? match[1].trim() : '';
+    }
+    async callLLM(prompt, maxTokens = 800) {
+        try {
+            const response = await fetch(`${this.llmUrl}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer 28b671e57e72c23a6a7aaae025bde6cbc7501784c5f7a370'
+                },
+                body: JSON.stringify({ messages: [{ role: 'user', content: prompt }], temperature: 0.3, max_tokens: maxTokens })
+            });
+            const data = await response.json();
+            return data.choices?.[0]?.message?.content || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    formatDate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+}
+//# sourceMappingURL=daily-review.js.map