@yulailai/openclaw-plugin-self-growth 3.1.6

package/dist/setup-wizard.js

@@ -0,0 +1,130 @@
+import * as fs from 'fs/promises';
+import { createWriteStream, chmodSync } from 'fs';
+import * as path from 'path';
+import https from 'https';
+const WELCOME_FILE = '.yulailai_welcome_shown';
+const CLOUD_BINARY = process.platform === 'win32' ? 'yulailai-cloud.exe' : 'yulailai-cloud';
+const DOWNLOAD_BASE = process.env.YULAI_CLOUD_URL || 'https://releases.yulailai.com/cloud/latest';
+export async function shouldShowWizard(basePath) {
+    try {
+        await fs.access(path.join(basePath, WELCOME_FILE));
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+export async function markWizardComplete(basePath) {
+    await fs.writeFile(path.join(basePath, WELCOME_FILE), new Date().toISOString(), 'utf-8');
+}
+export async function downloadCloudClient(basePath) {
+    const binDir = path.join(basePath, 'bin');
+    const binaryPath = path.join(binDir, CLOUD_BINARY);
+    try {
+        await fs.access(binaryPath);
+        return binaryPath;
+    }
+    catch { }
+    await fs.mkdir(binDir, { recursive: true });
+    const url = `${DOWNLOAD_BASE}/${CLOUD_BINARY}`;
+    console.log(`[yulailai] 正在下载云服务客户端...`);
+    return new Promise((resolve) => {
+        https.get(url, (res) => {
+            if (res.statusCode === 302 || res.statusCode === 301) {
+                https.get(res.headers.location, (redirectRes) => {
+                    const file = createWriteStream(binaryPath);
+                    redirectRes.pipe(file);
+                    file.on('finish', () => {
+                        chmodSync(binaryPath, 0o755);
+                        console.log('[yulailai] 云服务客户端就绪');
+                        resolve(binaryPath);
+                    });
+                }).on('error', () => {
+                    console.warn('[yulailai] 下载失败，离线模式可用');
+                    resolve(null);
+                });
+                return;
+            }
+            const file = createWriteStream(binaryPath);
+            res.pipe(file);
+            file.on('finish', () => {
+                chmodSync(binaryPath, 0o755);
+                console.log('[yulailai] 云服务客户端就绪');
+                resolve(binaryPath);
+            });
+        }).on('error', () => {
+            console.warn('[yulailai] 下载失败，离线模式可用');
+            resolve(null);
+        });
+    });
+}
+export function getWelcomeStep() {
+    return {
+        title: '欢迎使用 yulailai',
+        description: 'yulailai 帮助你的 AI Agent 跨设备共享记忆、偏好和技能。首次使用需要注册账号。',
+        options: [
+            { key: 'register', label: '注册新账号' },
+            { key: 'login', label: '已有账号，直接登录' },
+            { key: 'skip', label: '跳过，使用免费版（手动同步）' },
+        ],
+    };
+}
+export function getPlanStep() {
+    return {
+        title: '选择套餐',
+        description: '免费版支持手动同步，专业版和企业版支持自动同步。',
+        options: [
+            { key: 'free', label: '免费版 - 1GB 存储 | 1台设备 | 手动同步 | 免费', plan: 'free' },
+            { key: 'pro', label: '专业版 - 10GB 存储 | 5台设备 | 自动同步 | ¥15/月', plan: 'pro' },
+            { key: 'enterprise', label: '企业版 - 100GB 存储 | 不限设备 | 实时同步 | ¥3000/年', plan: 'enterprise' },
+        ],
+    };
+}
+export function getPaymentStep(plan, amount) {
+    const prices = { free: '免费', pro: '¥15/月', enterprise: '¥3000/年' };
+    return {
+        title: '扫码支付',
+        description: `套餐: ${plan === 'pro' ? '专业版' : '企业版'} | 金额: ${prices[plan]}\n\n请使用微信扫描二维码完成支付。支付完成后自动激活。`,
+        options: [
+            { key: 'paid', label: '已完成支付' },
+            { key: 'cancel', label: '取消，使用免费版' },
+        ],
+    };
+}
+export function getCompleteStep(plan) {
+    const names = { free: '免费版', pro: '专业版', enterprise: '企业版' };
+    return {
+        title: '设置完成',
+        description: `yulailai ${names[plan]}已就绪。\n\n你的 AI Agent 现在拥有跨设备记忆能力。`,
+        options: [
+            { key: 'done', label: '开始使用' },
+        ],
+    };
+}
+export async function handleRegister(serverUrl, username, email, password) {
+    const res = await fetch(`${serverUrl}/api/auth/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ username, email, password }),
+    });
+    if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error || '注册失败');
+    }
+    const data = await res.json();
+    return data.user;
+}
+export async function handleLogin(serverUrl, email, password) {
+    const res = await fetch(`${serverUrl}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+    });
+    if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error || '登录失败');
+    }
+    const data = await res.json();
+    return data.token;
+}
+//# sourceMappingURL=setup-wizard.js.map

package/dist/skill-generator.js

@@ -0,0 +1,259 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export class SkillGenerator {
+    outputDir;
+    constructor(workspacePath) {
+        this.outputDir = workspacePath;
+        this.ensureDirectoryExists(this.outputDir);
+    }
+    generate(taskName, steps, category) {
+        const skillDirName = this.convertToFolderName(taskName);
+        const skillDir = path.join(this.outputDir, skillDirName);
+        this.ensureDirectoryExists(skillDir);
+        const skillContent = this.buildSkillContent(taskName, steps, category);
+        const skillFilePath = path.join(skillDir, 'SKILL.md');
+        fs.writeFileSync(skillFilePath, skillContent, 'utf-8');
+        console.log(`✅ Skill 已生成: ${skillFilePath}`);
+        return skillFilePath;
+    }
+    listGenerated() {
+        if (!fs.existsSync(this.outputDir))
+            return [];
+        return fs.readdirSync(this.outputDir, { withFileTypes: true })
+            .filter(dirent => {
+            if (!dirent.isDirectory())
+                return false;
+            const skillFile = path.join(this.outputDir, dirent.name, 'SKILL.md');
+            return fs.existsSync(skillFile);
+        })
+            .map(dirent => dirent.name);
+    }
+    evaluateAndGenerate(taskContext) {
+        const sameTaskCount = this.countSimilarTask(taskContext.taskName);
+        const isRepeated = sameTaskCount >= 5;
+        const userRequested = /生成技能|记下这个流程|保存这个任务|记住这个流程/.test(taskContext.taskName);
+        if (!isRepeated && !userRequested) {
+            console.log(`[SkillGenerator] ℹ️ 不满足生成条件（相似:${sameTaskCount}次）`);
+            return false;
+        }
+        const existing = this.listGenerated();
+        const taskLower = taskContext.taskName.toLowerCase().replace(/\s+/g, '');
+        for (const name of existing) {
+            const nameLower = name.toLowerCase().replace(/\s+/g, '');
+            if (nameLower.includes(taskLower.substring(0, 6)) || taskLower.includes(nameLower.substring(0, 6))) {
+                const skillPath = path.join(this.outputDir, name, 'SKILL.md');
+                if (fs.existsSync(skillPath)) {
+                    let content = fs.readFileSync(skillPath, 'utf-8');
+                    content = content.replace(/last_used: .*/g, `last_used: ${new Date().toISOString()}`);
+                    content = content.replace(/status: .*/g, `status: active`);
+                    fs.writeFileSync(skillPath, content, 'utf-8');
+                    console.log(`[SkillGenerator] 🔄 技能已更新: ${name}`);
+                }
+                return true;
+            }
+        }
+        this.generate(taskContext.taskName, taskContext.steps, taskContext.category);
+        console.log(`[SkillGenerator] 🎓 自动生成新技能: ${taskContext.taskName}（相似:${sameTaskCount}次）`);
+        return true;
+    }
+    /**
+     * 标准化裸 .md 文件：移入子文件夹，补全 SKILL.md 的 frontmatter
+     */
+    normalizeSkillFiles() {
+        if (!fs.existsSync(this.outputDir))
+            return;
+        const entries = fs.readdirSync(this.outputDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            if (!entry.name.endsWith('.md'))
+                continue;
+            if (entry.name === 'SKILL.md')
+                continue;
+            const oldPath = path.join(this.outputDir, entry.name);
+            const skillName = entry.name.replace(/\.md$/, '');
+            const folderName = this.convertToFolderName(skillName);
+            const skillDir = path.join(this.outputDir, folderName);
+            try {
+                const content = fs.readFileSync(oldPath, 'utf-8');
+                if (content.startsWith('---')) {
+                    // 已有 frontmatter，逐个补全缺失字段
+                    this.ensureDirectoryExists(skillDir);
+                    let updated = content;
+                    const lines = updated.split('\n');
+                    const hasStatus = lines.some(l => l.startsWith('status:'));
+                    const hasCreated = lines.some(l => l.startsWith('created:'));
+                    const hasLastUsed = lines.some(l => l.startsWith('last_used:'));
+                    if (!hasStatus) {
+                        updated = updated.replace('---\n', `---\nstatus: active\n`);
+                    }
+                    if (!hasCreated) {
+                        updated = updated.replace('---\n', `---\ncreated: ${new Date().toISOString()}\n`);
+                    }
+                    if (!hasLastUsed) {
+                        updated = updated.replace('---\n', `---\nlast_used: ${new Date().toISOString()}\n`);
+                    }
+                    const newPath = path.join(skillDir, 'SKILL.md');
+                    fs.writeFileSync(newPath, updated, 'utf-8');
+                    fs.unlinkSync(oldPath);
+                    console.log(`[SkillGenerator] 📦 标准化技能文件: ${entry.name} → ${folderName}/SKILL.md`);
+                }
+                else {
+                    // 没有 frontmatter，补全后移入
+                    this.ensureDirectoryExists(skillDir);
+                    const fullContent = `---
+name: ${skillName}
+description: >
+  Agent 生成的技能文件，由 self-growth 插件自动标准化。
+category: 未分类
+user-invocable: true
+disable-model-invocation: false
+status: active
+created: ${new Date().toISOString()}
+last_used: ${new Date().toISOString()}
+---
+
+# ${skillName}
+
+${content}`;
+                    const newPath = path.join(skillDir, 'SKILL.md');
+                    fs.writeFileSync(newPath, fullContent, 'utf-8');
+                    fs.unlinkSync(oldPath);
+                    console.log(`[SkillGenerator] 📦 标准化技能文件（已补全 frontmatter）: ${entry.name} → ${folderName}/SKILL.md`);
+                }
+            }
+            catch (err) {
+                console.error(`[SkillGenerator] ⚠️ 标准化失败 [${entry.name}]:`, err);
+            }
+        }
+    }
+    countSimilarTask(taskName) {
+        const existing = this.listGenerated();
+        const taskLower = taskName.toLowerCase().replace(/\s+/g, '').substring(0, 6);
+        let count = 1;
+        for (const name of existing) {
+            const nameLower = name.toLowerCase().replace(/\s+/g, '');
+            if (nameLower.includes(taskLower) || taskLower.includes(nameLower)) {
+                count++;
+            }
+        }
+        return count;
+    }
+    manageLifecycle() {
+        this.normalizeSkillFiles();
+        const now = Date.now();
+        const skillNames = this.listGenerated();
+        for (const name of skillNames) {
+            const skillPath = path.join(this.outputDir, name, 'SKILL.md');
+            try {
+                const content = fs.readFileSync(skillPath, 'utf-8');
+                const lastUsed = this.parseLastUsed(content, skillPath);
+                const unusedDays = (now - lastUsed) / 86400000;
+                if (unusedDays < 0) {
+                    this.markUsed(name);
+                    console.log(`[SkillGenerator] ⚠️ 技能时间异常，已重置为今天: ${name}`);
+                    continue;
+                }
+                const currentStatus = this.parseStatus(content);
+                if (unusedDays > 90) {
+                    const skillDir = path.join(this.outputDir, name);
+                    fs.rmSync(skillDir, { recursive: true });
+                    console.log(`[SkillGenerator] 🗑️ 技能已删除（${Math.round(unusedDays)}天未使用）: ${name}`);
+                }
+                else if (unusedDays > 30 && currentStatus !== 'watch') {
+                    this.updateStatus(skillPath, 'watch');
+                    console.log(`[SkillGenerator] 👀 技能进入观察期（${Math.round(unusedDays)}天未使用）: ${name}`);
+                }
+            }
+            catch (err) {
+                console.error(`[SkillGenerator] ⚠️ 管理技能失败 [${name}]:`, err);
+            }
+        }
+    }
+    markUsed(skillName) {
+        const folderName = this.convertToFolderName(skillName);
+        const skillPath = path.join(this.outputDir, folderName, 'SKILL.md');
+        if (!fs.existsSync(skillPath))
+            return;
+        let content = fs.readFileSync(skillPath, 'utf-8');
+        content = content.replace(/last_used: .*/g, `last_used: ${new Date().toISOString()}`);
+        content = content.replace(/status: .*/g, `status: active`);
+        fs.writeFileSync(skillPath, content, 'utf-8');
+    }
+    parseLastUsed(content, filePath) {
+        const match = content.match(/last_used: (.+)/);
+        if (match) {
+            const d = new Date(match[1]);
+            if (!isNaN(d.getTime()))
+                return d.getTime();
+        }
+        const createdMatch = content.match(/生成时间: (.+)/);
+        if (createdMatch) {
+            const d = new Date(createdMatch[1]);
+            if (!isNaN(d.getTime()))
+                return d.getTime();
+        }
+        if (filePath) {
+            try {
+                const stat = fs.statSync(filePath);
+                return stat.mtimeMs;
+            }
+            catch { }
+        }
+        return Date.now();
+    }
+    parseStatus(content) {
+        const match = content.match(/status: (.+)/);
+        return match ? match[1].trim() : 'active';
+    }
+    updateStatus(skillPath, status) {
+        let content = fs.readFileSync(skillPath, 'utf-8');
+        if (content.includes('status:')) {
+            content = content.replace(/status: .*/g, `status: ${status}`);
+        }
+        else {
+            content = content.replace(/生成插件: self-growth/, `status: ${status}\n生成插件: self-growth`);
+        }
+        fs.writeFileSync(skillPath, content, 'utf-8');
+    }
+    ensureDirectoryExists(dir) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    convertToFolderName(taskName) {
+        return taskName.length > 40 ? taskName.substring(0, 40) : taskName;
+    }
+    buildSkillContent(taskName, steps, category) {
+        const stepsMarkdown = steps
+            .map((step, index) => `${index + 1}. ${step}`)
+            .join('\n');
+        return `---
+name: ${taskName}
+description: >
+  自动生成的技能。此技能由 self-growth 插件自动生成。
+category: ${category}
+user-invocable: true
+disable-model-invocation: false
+status: active
+created: ${new Date().toISOString()}
+last_used: ${new Date().toISOString()}
+---
+
+# ${taskName}
+
+## 🔄 核心工作流
+${stepsMarkdown}
+
+## ✅ 完成标准
+- 所有步骤已按顺序执行完毕
+
+## 📝 技能信息
+- **生成时间**: ${new Date().toISOString()}
+- **任务类别**: ${category}
+- **状态**: active
+- **生成插件**: self-growth
+`;
+    }
+}
+//# sourceMappingURL=skill-generator.js.map