@yulailai/openclaw-plugin-self-growth 3.1.6

package/dist/skill-optimizer.js

@@ -0,0 +1,393 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export class SkillOptimizer {
+    skillsDir;
+    llmUrl;
+    llmModel;
+    scores;
+    pendingUpgradesPath;
+    constructor(storageDir = './memory', llmUrl = 'http://127.0.0.1:1234/v1', llmModel = 'qwen/qwen3.5-9b') {
+        this.skillsDir = path.join(storageDir, 'skills');
+        this.llmUrl = llmUrl;
+        this.llmModel = llmModel;
+        this.scores = new Map();
+        this.pendingUpgradesPath = path.join(this.skillsDir, 'pending_upgrades.json');
+    }
+    async init() {
+        await fs.mkdir(this.skillsDir, { recursive: true });
+    }
+    async generateSkill(taskRecord) {
+        const skillName = taskRecord.name;
+        const skillDir = path.join(this.skillsDir, skillName);
+        const skillFilePath = path.join(skillDir, 'SKILL.md');
+        await fs.mkdir(skillDir, { recursive: true });
+        const content = this.buildSkillMarkdown(skillName, taskRecord);
+        try {
+            await fs.writeFile(skillFilePath, content, 'utf-8');
+            console.log(`[SkillOptimizer] ✨ 成功生成 SKILL.md: ${skillFilePath}`);
+            return skillFilePath;
+        }
+        catch (error) {
+            console.error(`[SkillOptimizer] ❌ 生成 SKILL.md 失败 [${skillName}]:`, error);
+            throw error;
+        }
+    }
+    async batchGenerate(readyTasks) {
+        const generatedFiles = [];
+        for (const task of readyTasks) {
+            try {
+                const filePath = await this.generateSkill(task);
+                generatedFiles.push(filePath);
+            }
+            catch (error) {
+                console.warn(`[SkillOptimizer] ⚠️ 跳过任务 [${task.name}]:`, error);
+            }
+        }
+        return generatedFiles;
+    }
+    async batchGenerateFromLLM(tasks) {
+        const generatedFiles = [];
+        for (const task of tasks) {
+            try {
+                const taskRecord = {
+                    name: task.taskName,
+                    category: "自动生成",
+                    count: 1,
+                    steps: task.steps,
+                    history: [{ time: new Date().toISOString(), steps: task.steps }],
+                    readyForSkill: true,
+                    runIds: []
+                };
+                const filePath = await this.generateSkill(taskRecord);
+                generatedFiles.push(filePath);
+            }
+            catch (error) {
+                console.warn(`[SkillOptimizer] ⚠️ 跳过任务 [${task.taskName}]:`, error);
+            }
+        }
+        return generatedFiles;
+    }
+    async listGenerated() {
+        try {
+            const entries = await fs.readdir(this.skillsDir, { withFileTypes: true });
+            return entries
+                .filter(e => e.isDirectory())
+                .filter(e => {
+                const skillFile = path.join(this.skillsDir, e.name, 'SKILL.md');
+                return fs.access(skillFile).then(() => true).catch(() => false);
+            })
+                .map(e => e.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    async getExistingSkill(skillName) {
+        const skillFilePath = path.join(this.skillsDir, skillName, 'SKILL.md');
+        try {
+            return await fs.readFile(skillFilePath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    recordExecution(skillName, success, durationMs, hadManualFix = false) {
+        if (!this.scores.has(skillName)) {
+            this.scores.set(skillName, { recentScores: [], optimizeCount: 0, usageCount: 0, lastUsed: Date.now() });
+        }
+        const record = this.scores.get(skillName);
+        record.usageCount += 1;
+        record.lastUsed = Date.now();
+        let score = 100;
+        if (!success)
+            score -= 30;
+        if (durationMs > 60000)
+            score -= 15;
+        if (hadManualFix)
+            score -= 25;
+        record.recentScores.push(score);
+        if (record.recentScores.length > 10) {
+            record.recentScores.shift();
+        }
+        const recent = record.recentScores;
+        if (recent.length >= 3 && recent.slice(-3).every(s => s < 80)) {
+            return true;
+        }
+        return false;
+    }
+    async calculateComprehensiveScore(skillName) {
+        const record = this.scores.get(skillName) || { recentScores: [], optimizeCount: 0, usageCount: 0, lastUsed: 0 };
+        const content = await this.getExistingSkill(skillName);
+        let reuse = 0;
+        if (record.usageCount >= 10)
+            reuse += 20;
+        else if (record.usageCount >= 5)
+            reuse += 15;
+        else if (record.usageCount >= 1)
+            reuse += 10;
+        const daysSinceUsed = (Date.now() - record.lastUsed) / 86400000;
+        if (daysSinceUsed < 7)
+            reuse += 10;
+        else if (daysSinceUsed < 30)
+            reuse += 5;
+        if (daysSinceUsed < 1)
+            reuse += 10;
+        let quality = 0;
+        const recentScores = record.recentScores.slice(-10);
+        if (recentScores.length > 0) {
+            const avgScore = recentScores.reduce((a, b) => a + b, 0) / recentScores.length;
+            quality = Math.round(avgScore * 0.4);
+        }
+        else {
+            quality = 20;
+        }
+        let structure = 0;
+        if (content) {
+            if (/## 🔄 核心工作流/.test(content))
+                structure += 5;
+            if (/## ✅ 完成标准/.test(content))
+                structure += 5;
+            if (/## ⚠️ 注意事项|## 🚫 不适用/.test(content))
+                structure += 5;
+            if (content.split('\n').filter(l => /^\d+\./.test(l.trim())).length >= 3)
+                structure += 5;
+        }
+        return { total: reuse + quality + structure, reuse, quality, structure };
+    }
+    async evaluateAndCleanup() {
+        const skillNames = await this.listGenerated();
+        const suggestions = [];
+        const now = Date.now();
+        for (const skillName of skillNames) {
+            const score = await this.calculateComprehensiveScore(skillName);
+            const record = this.scores.get(skillName);
+            if (score.total < 50) {
+                const skillDir = path.join(this.skillsDir, skillName);
+                try {
+                    await fs.rm(skillDir, { recursive: true });
+                }
+                catch { }
+                console.log(`[SkillOptimizer] 🗑️ 技能评分过低(${score.total}分)，已删除: ${skillName}`);
+                continue;
+            }
+            if (score.total < 80) {
+                const content = await this.getExistingSkill(skillName);
+                if (content && this.parseStatus(content) === 'watch') {
+                    const skillDir = path.join(this.skillsDir, skillName);
+                    try {
+                        await fs.rm(skillDir, { recursive: true });
+                    }
+                    catch { }
+                    console.log(`[SkillOptimizer] 🗑️ 观察期技能评分不足(${score.total}分)，已删除: ${skillName}`);
+                    continue;
+                }
+            }
+            const daysSinceUsed = (now - (record?.lastUsed || 0)) / 86400000;
+            if (record && record.usageCount >= 3 && daysSinceUsed <= 7 && score.total >= 50 && score.total < 80) {
+                const suggestion = await this.generateUpgradeSuggestion(skillName, score.total);
+                suggestions.push(suggestion);
+                console.log(`[SkillOptimizer] 💡 生成升级建议: ${skillName}（评分:${score.total} 使用:${record.usageCount}次）`);
+            }
+        }
+        if (suggestions.length > 0) {
+            await fs.writeFile(this.pendingUpgradesPath, JSON.stringify(suggestions, null, 2), 'utf-8');
+        }
+        else {
+            try {
+                await fs.unlink(this.pendingUpgradesPath);
+            }
+            catch { }
+        }
+        return suggestions;
+    }
+    async generateUpgradeSuggestion(skillName, currentScore) {
+        const content = await this.getExistingSkill(skillName);
+        let suggestion = `建议优化"${skillName}"技能（当前评分${currentScore}），可考虑：简化冗余步骤、补充完成标准、添加不适用场景说明。`;
+        if (content) {
+            try {
+                const prompt = `分析以下技能文件，给出1-2条具体的优化建议（每条约20字）：
+${content.substring(0, 1500)}
+
+评分较低的原因可能有：步骤冗余、缺少完成标准、缺少边界说明。请直接输出建议：`;
+                const llmSuggestion = await this.callLLM(prompt, 200);
+                if (llmSuggestion)
+                    suggestion = llmSuggestion;
+            }
+            catch { }
+        }
+        return { skillName, currentScore, suggestion, generatedAt: new Date().toISOString(), status: 'pending' };
+    }
+    async getPendingUpgrades() {
+        try {
+            const data = await fs.readFile(this.pendingUpgradesPath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    async updateUpgradeStatus(skillName, status) {
+        const upgrades = await this.getPendingUpgrades();
+        const updated = upgrades.filter(u => u.skillName !== skillName);
+        if (updated.length === 0) {
+            try {
+                await fs.unlink(this.pendingUpgradesPath);
+            }
+            catch { }
+        }
+        else {
+            await fs.writeFile(this.pendingUpgradesPath, JSON.stringify(updated, null, 2), 'utf-8');
+        }
+    }
+    getAverageScore(skillName) {
+        const record = this.scores.get(skillName);
+        if (!record || record.recentScores.length === 0)
+            return 100;
+        const recent = record.recentScores.slice(-5);
+        return recent.reduce((sum, s) => sum + s, 0) / recent.length;
+    }
+    resetScores(skillName) {
+        const record = this.scores.get(skillName);
+        if (record) {
+            record.recentScores = [];
+            record.optimizeCount += 1;
+        }
+    }
+    async detectChanges(skillName, recentLogs) {
+        const prompt = `分析以下对话日志，判断"${skillName}"技能的使用模式是否发生了变化。如果有变化，简要说明；如果没有，回复"无变化"。\n\n对话日志：\n${recentLogs.slice(0, 3000)}`;
+        const response = await this.callLLM(prompt, 300);
+        return response && response !== '无变化' ? response : null;
+    }
+    async diagnoseAndPatch(skillName, skillContent, recentLogs) {
+        const prompt = `分析以下日志，诊断"${skillName}"技能的缺陷：\n1. 哪些步骤经常失败？原因是什么？\n2. 用户在对话中如何进行手动修正？\n3. 提供精确的修改方案，只修改有问题的部分。\n\n旧版 SKILL.md：\n${skillContent.slice(0, 3000)}\n\n最近对话日志：\n${recentLogs.slice(0, 3000)}\n\n返回 JSON：{"problemsFound": true/false, "diagnosis": "...", "patchInstruction": "..."}`;
+        const response = await this.callLLM(prompt, 1000);
+        try {
+            return JSON.parse(response || '{}');
+        }
+        catch {
+            return { problemsFound: false, diagnosis: '', patchInstruction: '' };
+        }
+    }
+    async applyPatch(skillPath, patchInstruction) {
+        if (!patchInstruction)
+            return false;
+        try {
+            const oldContent = await fs.readFile(skillPath, 'utf-8');
+            const prompt = `根据以下指令修改 SKILL.md 文件。保留 YAML frontmatter 不变，只修改 Markdown 正文。\n原始文件：\n${oldContent}\n\n修改指令：\n${patchInstruction}\n\n返回完整的、可直接保存的 SKILL.md 内容。`;
+            let newContent = await this.callLLM(prompt, 3000);
+            if (newContent && newContent.length > 200) {
+                const frontmatterEnd = oldContent.indexOf('---', 4);
+                if (frontmatterEnd !== -1) {
+                    const oldFrontmatter = oldContent.substring(0, frontmatterEnd + 3);
+                    const newFrontmatterEnd = newContent.indexOf('---', 4);
+                    if (newFrontmatterEnd !== -1) {
+                        const newFrontmatter = newContent.substring(0, newFrontmatterEnd + 3);
+                        newContent = oldFrontmatter + newContent.substring(newFrontmatter.length);
+                    }
+                }
+                await fs.writeFile(skillPath, newContent, 'utf-8');
+                return true;
+            }
+        }
+        catch (error) {
+            console.error('[SkillOptimizer] ❌ 修复失败:', error);
+        }
+        return false;
+    }
+    async evaluateAndOptimize(recentLogs) {
+        const skillNames = await this.listGenerated();
+        let optimizedCount = 0;
+        for (const skillName of skillNames) {
+            const avgScore = this.getAverageScore(skillName);
+            if (avgScore >= 80)
+                continue;
+            const skillContent = await this.getExistingSkill(skillName);
+            if (!skillContent)
+                continue;
+            try {
+                const diagnosis = await this.diagnoseAndPatch(skillName, skillContent, recentLogs);
+                if (!diagnosis.problemsFound)
+                    continue;
+                const skillPath = path.join(this.skillsDir, skillName, 'SKILL.md');
+                const patched = await this.applyPatch(skillPath, diagnosis.patchInstruction);
+                if (patched) {
+                    this.resetScores(skillName);
+                    optimizedCount++;
+                }
+            }
+            catch (err) {
+                console.error(`[SkillOptimizer] ❌ 技能 "${skillName}" 优化失败:`, err);
+            }
+        }
+        console.log(`[SkillOptimizer] 📊 本轮共优化 ${optimizedCount} 个技能`);
+        return optimizedCount;
+    }
+    parseStatus(content) {
+        const match = content.match(/status: (.+)/);
+        return match ? match[1].trim() : 'active';
+    }
+    buildSkillMarkdown(name, record) {
+        const stepsMarkdown = this.optimizeSteps(record.steps)
+            .map((step, index) => `${index + 1}. ${step}`)
+            .join('\n');
+        return `---
+name: ${name}
+description: >
+  自动生成的技能。触发条件：用户提到'执行${name}'或相关描述时，自动调用此技能。
+  此技能由 self-growth 插件自动生成，基于用户 ${record.count} 次执行此任务的流程。
+category: ${record.category}
+user-invocable: true
+disable-model-invocation: false
+---
+
+# ${name}
+
+## 🎯 触发条件
+当用户提到执行"${name}"任务时，自动调用此技能。
+
+## 🔄 核心工作流
+${stepsMarkdown}
+
+## ✅ 完成标准
+- 所有步骤已按顺序执行完毕
+- 每步结果已向用户汇报
+
+## 📤 输出与交付
+- 每步执行完成后，简要汇报结果
+- 全部完成后，输出任务总结
+
+## 📝 技能信息
+- **生成时间**: ${new Date().toISOString()}
+- **任务类别**: ${record.category}
+- **步骤数量**: ${record.steps.length}
+- **执行次数**: ${record.count}
+- **生成插件**: self-growth
+`;
+    }
+    optimizeSteps(steps) {
+        if (!steps || steps.length === 0)
+            return [];
+        let optimized = steps.map(step => step.trim()).filter(step => step.length > 0);
+        return Array.from(new Set(optimized));
+    }
+    async callLLM(prompt, maxTokens = 800) {
+        try {
+            const response = await fetch(`${this.llmUrl}/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                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 (error) {
+            console.error('[SkillOptimizer] LLM 调用失败:', error);
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=skill-optimizer.js.map

package/dist/sync-client.js

@@ -0,0 +1,220 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { loadActivation } from './payment';
+import { getCachedToken, loginAndGetToken } from './auth-client';
+export class SyncClient {
+    config;
+    timer = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async start(basePath) {
+        const activation = await loadActivation(basePath);
+        if (activation.plan === 'free') {
+            console.log('[SyncClient] 免费版，手动同步模式');
+            return;
+        }
+        this.timer = setInterval(() => this.sync(basePath), this.config.interval);
+        console.log(`[SyncClient] 自动同步已启动 (间隔: ${this.config.interval / 1000}s)`);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    async sync(basePath) {
+        const activation = await loadActivation(basePath);
+        if (activation.plan === 'free')
+            return;
+        const email = activation?.email || '';
+        if (!email)
+            return;
+        // 获取 JWT token
+        const auth = getCachedToken() || await loginAndGetToken(this.config.serverUrl, email, basePath);
+        if (!auth) {
+            console.error('[SyncClient] 无法获取认证 token');
+            return;
+        }
+        // 同步记忆数据
+        await this.syncPreferences(basePath, auth.token);
+        // 同步 chat_logs 和 skills 作为备份文件
+        await this.syncFiles(basePath, auth.token);
+    }
+    async syncPreferences(basePath, token) {
+        try {
+            const prefsPath = path.join(basePath, 'memory', 'user_preferences.md');
+            const content = await fs.readFile(prefsPath, 'utf-8').catch(() => '');
+            if (!content.trim())
+                return;
+            // 解析本地偏好文件，提取条目
+            const items = this.parsePreferences(content);
+            if (items.length === 0)
+                return;
+            // 按类型分组上传
+            const typeGroups = {};
+            for (const item of items) {
+                if (!typeGroups[item.type])
+                    typeGroups[item.type] = [];
+                typeGroups[item.type].push(item);
+            }
+            for (const [type, typeItems] of Object.entries(typeGroups)) {
+                await fetch(`${this.config.serverUrl}/api/sync/push`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({
+                        type,
+                        items: typeItems.map(item => ({
+                            content: JSON.stringify({ text: item.text, source: item.source }),
+                            confidence: item.confidence,
+                        })),
+                    }),
+                    signal: AbortSignal.timeout(15000),
+                });
+            }
+            console.log(`[SyncClient] 偏好同步完成: ${items.length} 条`);
+        }
+        catch (err) {
+            console.error('[SyncClient] 偏好同步失败:', err);
+        }
+    }
+    async syncFiles(basePath, token) {
+        // 同步编译后的记忆文件到 memory API
+        try {
+            const compiledDir = path.join(basePath, 'memory', 'compiled');
+            const files = ['memory.md', 'preferences.md', 'lessons.md'];
+            for (const file of files) {
+                const content = await fs.readFile(path.join(compiledDir, file), 'utf-8').catch(() => '');
+                if (!content.trim())
+                    continue;
+                const type = file.replace('.md', '') === 'memory' ? 'preference' : file.replace('.md', '');
+                await fetch(`${this.config.serverUrl}/api/memory/${type}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({ content, confidence: 3 }),
+                    signal: AbortSignal.timeout(15000),
+                });
+            }
+            console.log('[SyncClient] 记忆文件同步完成');
+        }
+        catch (err) {
+            console.error('[SyncClient] 文件同步失败:', err);
+        }
+    }
+    parsePreferences(markdown) {
+        const items = [];
+        const lines = markdown.split('\n');
+        let currentType = 'preference';
+        const typeMap = {
+            '偏好': 'preference',
+            '习惯': 'habit',
+            '事实': 'fact',
+            '决定': 'decision',
+            '教训': 'lesson',
+            '技能': 'skill',
+        };
+        for (const line of lines) {
+            // 检测类型标题
+            const headingMatch = line.match(/^##\s+(?:[^\s]+\s+)?(.+)$/);
+            if (headingMatch) {
+                const headingText = headingMatch[1].trim();
+                for (const [label, type] of Object.entries(typeMap)) {
+                    if (headingText.includes(label)) {
+                        currentType = type;
+                        break;
+                    }
+                }
+                continue;
+            }
+            // 跳过统计行
+            if (line.startsWith('## 📊') || line.startsWith('---') || line.startsWith('>')) {
+                continue;
+            }
+            // 解析条目
+            if (line.trim().startsWith('- ')) {
+                const text = line.trim().substring(2).trim();
+                // 提取星级
+                const starMatch = text.match(/\[([★☆]+)\]/);
+                const confidence = starMatch
+                    ? (starMatch[1].match(/★/g) || []).length
+                    : 1;
+                const cleanText = text.replace(/\[[★☆]+\]\s*/, '');
+                if (cleanText && !cleanText.includes('*暂无') && !cleanText.startsWith('**')) {
+                    items.push({
+                        type: currentType,
+                        text: cleanText,
+                        confidence,
+                        source: 'user_preferences.md',
+                    });
+                }
+            }
+        }
+        return items;
+    }
+    async restore(basePath) {
+        const activation = await loadActivation(basePath);
+        if (activation.plan === 'free')
+            return;
+        const email = activation?.email || '';
+        if (!email)
+            return;
+        const auth = getCachedToken() || await loginAndGetToken(this.config.serverUrl, email, basePath);
+        if (!auth)
+            return;
+        // 拉取所有类型的数据
+        const types = ['preference', 'habit', 'fact', 'decision', 'lesson', 'skill'];
+        const allItems = [];
+        for (const type of types) {
+            try {
+                const res = await fetch(`${this.config.serverUrl}/api/sync/pull?type=${type}`, {
+                    headers: { 'Authorization': `Bearer ${auth.token}` },
+                    signal: AbortSignal.timeout(10000),
+                });
+                if (res.ok) {
+                    const data = await res.json();
+                    if (data.items) {
+                        allItems.push(...data.items.map((item) => ({ ...item, type })));
+                    }
+                }
+            }
+            catch { }
+        }
+        // 重建本地偏好文件
+        const typeLabels = {
+            preference: '偏好',
+            habit: '习惯',
+            fact: '事实',
+            decision: '决定',
+            lesson: '教训',
+            skill: '技能',
+        };
+        let markdown = `# 用户偏好\n\n> 自动同步于 ${new Date().toISOString()}\n\n`;
+        const groups = {};
+        for (const item of allItems) {
+            if (!groups[item.type])
+                groups[item.type] = [];
+            groups[item.type].push(item);
+        }
+        for (const [type, items] of Object.entries(groups)) {
+            markdown += `## ${typeLabels[type] || type}\n\n`;
+            for (const item of items) {
+                const content = typeof item.content === 'string'
+                    ? JSON.parse(item.content).text
+                    : item.content?.text || '';
+                const stars = '★'.repeat(item.confidence || 1);
+                markdown += `- [${stars}] ${content}\n`;
+            }
+            markdown += '\n';
+        }
+        await fs.mkdir(path.dirname(path.join(basePath, 'memory', 'user_preferences.md')), { recursive: true });
+        await fs.writeFile(path.join(basePath, 'memory', 'user_preferences.md'), markdown);
+        console.log(`[SyncClient] 数据恢复完成: ${allItems.length} 条`);
+    }
+}
+//# sourceMappingURL=sync-client.js.map