@yulailai/openclaw-plugin-self-growth 3.1.6

package/dist/memory-manager.js

@@ -0,0 +1,374 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { TaskTracker } from './task-tracker';
+import { SkillOptimizer } from './skill-optimizer';
+import { DailyReviewer } from './daily-review';
+import { ChatLogger } from './chat-logger';
+import { PreferenceExtractor } from './preference-extractor';
+export class MemoryManager {
+    storageDir;
+    llmUrl;
+    llmModel;
+    chatLogger;
+    preferenceExtractor;
+    taskTracker;
+    skillOptimizer;
+    dailyReviewer;
+    preferences = [];
+    preferenceFilePath;
+    fileHeader = `# 用户偏好记忆
+
+> 📝 本文件由 self-growth 插件自动维护
+> ⚠️ 你可以手动编辑，但请注意格式
+> 📅 最后更新：{{lastUpdated}}
+
+---
+
+`;
+    typeLabels = {
+        preference: '偏好',
+        habit: '习惯',
+        fact: '事实',
+        decision: '决定'
+    };
+    constructor(storageDir = './memory', llmUrl = 'http://127.0.0.1:1234/v1', llmModel = 'qwen/qwen3.5-9b') {
+        this.storageDir = storageDir;
+        this.llmUrl = llmUrl;
+        this.llmModel = llmModel;
+        this.preferenceFilePath = path.join(this.storageDir, 'user_preferences.md');
+        this.chatLogger = new ChatLogger(this.storageDir);
+        this.preferenceExtractor = new PreferenceExtractor(this.llmUrl);
+        this.taskTracker = new TaskTracker(this.storageDir);
+        this.skillOptimizer = new SkillOptimizer(this.storageDir, this.llmUrl, this.llmModel);
+        this.dailyReviewer = new DailyReviewer(this.chatLogger, this.preferenceExtractor, this.taskTracker, this.skillOptimizer, this.llmUrl, this.llmModel, this.storageDir);
+    }
+    async boot() {
+        console.log('[MemoryManager] 🚀 正在启动 self-growth 记忆中枢...');
+        try {
+            await fs.mkdir(this.storageDir, { recursive: true });
+            console.log(`[MemoryManager] 📂 存储目录已就绪: ${this.storageDir}`);
+            await Promise.all([
+                this.taskTracker.init(),
+                this.skillOptimizer.init(),
+                this.loadPreferences()
+            ]);
+            console.log('[MemoryManager] ✅ 记忆中枢启动完成，自我进化系统已激活！\n');
+        }
+        catch (error) {
+            console.error('[MemoryManager] ❌ 启动过程中发生严重错误:', error);
+            throw error;
+        }
+    }
+    async shutdown() {
+        console.log('[MemoryManager] 🛑 正在关闭记忆中枢...');
+        await this.writePreferences();
+        console.log('[MemoryManager] ✅ 记忆中枢已安全关闭。');
+    }
+    getActiveTasks() {
+        return this.taskTracker.getActiveTasks();
+    }
+    async triggerDailyReview() {
+        console.log('[MemoryManager] ⏳ 收到手动触发复盘指令...');
+        return await this.dailyReviewer.runDailyReview();
+    }
+    async addPreference(preference) {
+        const now = Date.now();
+        const existingIndex = this.preferences.findIndex((existing) => {
+            const a = existing.text.trim().replace(/\s+/g, '');
+            const b = preference.text.trim().replace(/\s+/g, '');
+            return a === b || (a.length > 2 && b.length > 2 &&
+                (a.includes(b) || b.includes(a)) &&
+                Math.abs(a.length - b.length) / Math.max(a.length, b.length) < 0.3);
+        });
+        if (existingIndex !== -1) {
+            const existing = this.preferences[existingIndex];
+            existing.occurrences += 1;
+            existing.lastMentioned = now;
+            if (existing.confidence < 5) {
+                existing.confidence = Math.min(5, Math.floor(existing.occurrences / 2) + 1);
+            }
+            console.log(`[MemoryManager] ⬆️ 偏好升级: [${existing.confidence}★] ${existing.text}`);
+            await this.writePreferences();
+            return true;
+        }
+        if (this.preferences.length >= 100) {
+            const removed = this.preferences.shift();
+            console.log(`[MemoryManager] 🧹 已满100条，移除最早记录: ${removed?.text}`);
+        }
+        if (this.preferences.length >= 50) {
+            console.warn(`[MemoryManager] ⚠️ 偏好已达 ${this.preferences.length} 条，建议清理旧偏好`);
+        }
+        const scored = {
+            ...preference,
+            confidence: 1,
+            occurrences: 1,
+            lastMentioned: now
+        };
+        this.preferences.push(scored);
+        await this.writePreferences();
+        console.log(`[MemoryManager] ✅ 新增记忆 [${scored.confidence}★]: [${this.typeLabels[preference.type] || preference.type}] ${preference.text}`);
+        return true;
+    }
+    autoDegrade() {
+        const now = Date.now();
+        let degraded = 0;
+        for (const pref of this.preferences) {
+            const daysSinceMention = (now - pref.lastMentioned) / 86400000;
+            if (daysSinceMention > 30 && pref.confidence > 1) {
+                pref.confidence -= 1;
+                pref.lastMentioned = now;
+                degraded++;
+            }
+        }
+        if (degraded > 0) {
+            console.log(`[MemoryManager] 📉 ${degraded} 条偏好因长期未提及被降星`);
+            this.writePreferences();
+        }
+    }
+    async addPreferences(preferences) {
+        let addedCount = 0;
+        for (const pref of preferences) {
+            const added = await this.addPreference(pref);
+            if (added)
+                addedCount++;
+        }
+        if (addedCount > 0) {
+            console.log(`[MemoryManager] 📊 批量添加完成: ${addedCount}/${preferences.length} 条`);
+        }
+        return addedCount;
+    }
+    getPreferences(type) {
+        if (type) {
+            return this.preferences.filter((p) => p.type === type);
+        }
+        return [...this.preferences];
+    }
+    searchPreferences(query) {
+        const lowerQuery = query.toLowerCase();
+        return this.preferences.filter((p) => p.text.toLowerCase().includes(lowerQuery));
+    }
+    async removePreference(text) {
+        const index = this.preferences.findIndex((p) => p.text.trim() === text.trim());
+        if (index === -1)
+            return false;
+        const removed = this.preferences.splice(index, 1)[0];
+        await this.writePreferences();
+        console.log(`[MemoryManager] 🗑️ 已删除记忆: ${removed.text}`);
+        return true;
+    }
+    async clearPreferences() {
+        this.preferences = [];
+        await this.writePreferences();
+        console.log('[MemoryManager] 🧹 所有偏好记忆已清空');
+    }
+    getPreferenceStats() {
+        const byType = {};
+        for (const pref of this.preferences) {
+            byType[pref.type] = (byType[pref.type] || 0) + 1;
+        }
+        return {
+            total: this.preferences.length,
+            byType,
+            lastUpdated: new Date().toISOString()
+        };
+    }
+    getPreferencesForRetrieval() {
+        return this.preferences.map(p => ({
+            text: p.text,
+            confidence: p.confidence,
+            type: p.type
+        }));
+    }
+    formatPreferencesForContext(maxItems) {
+        if (this.preferences.length === 0) {
+            return '（暂无用户偏好记录）';
+        }
+        const sorted = [...this.preferences].sort((a, b) => b.confidence - a.confidence);
+        let items = sorted;
+        if (maxItems && maxItems > 0) {
+            items = sorted.slice(0, maxItems);
+        }
+        const lines = items.map((p) => {
+            const stars = '★'.repeat(p.confidence) + '☆'.repeat(5 - p.confidence);
+            const label = this.typeLabels[p.type] || p.type;
+            return `- [${label}] [${stars}] ${p.text}`;
+        });
+        return `## 用户偏好记忆\n\n${lines.join('\n')}`;
+    }
+    async getRelevantMemories(context, limit = 5) {
+        if (this.preferences.length === 0) {
+            return "（暂无用户偏好记录）";
+        }
+        const highConf = this.preferences.filter(p => p.confidence >= 4);
+        const lowConf = this.preferences.filter(p => p.confidence < 4);
+        if (this.preferences.length <= 10) {
+            return this.formatSorted(highConf, lowConf, limit);
+        }
+        try {
+            const allSorted = [...this.preferences].sort((a, b) => b.confidence - a.confidence);
+            const memoryList = allSorted
+                .map((p, i) => `${i + 1}. [${p.confidence}★] [${this.typeLabels[p.type] || p.type}] ${p.text}`)
+                .join('\n');
+            const prompt = `从以下记忆列表中选出与用户问题最相关的 ${limit} 条记忆，只返回编号（如：2,5,7）。
+高星级表示该记忆被多次提及，应优先选择。
+
+用户问题：${context}
+
+记忆列表：
+${memoryList}
+
+最相关记忆编号：`;
+            const res = await fetch(`${this.llmUrl}/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: this.llmModel,
+                    messages: [{ role: 'user', content: prompt }],
+                    temperature: 0.1,
+                    max_tokens: 50
+                })
+            });
+            const data = await res.json();
+            const answer = data?.choices?.[0]?.message?.content?.trim() || '';
+            const indices = (answer.match(/\d+/g) || []).map(Number);
+            const selected = indices
+                .filter((i) => i >= 1 && i <= allSorted.length)
+                .map((i) => allSorted[i - 1]);
+            if (selected.length === 0) {
+                return this.formatSorted(highConf, lowConf, limit);
+            }
+            return this.formatResult(selected);
+        }
+        catch {
+            return this.formatSorted(highConf, lowConf, limit);
+        }
+    }
+    formatSorted(high, low, limit) {
+        const combined = [...high, ...low].slice(0, limit);
+        return this.formatResult(combined);
+    }
+    formatResult(items) {
+        const lessons = items.filter(p => p.text.startsWith('[教训]'));
+        const normalPrefs = items.filter(p => !p.text.startsWith('[教训]'));
+        let result = '';
+        if (lessons.length > 0) {
+            result += `## ⚠️ 错误教训（务必避免重复）\n\n${lessons.map(p => `- ${p.text}`).join('\n')}\n\n`;
+        }
+        if (normalPrefs.length > 0) {
+            result += `## 👤 用户偏好（与当前话题相关）\n\n${normalPrefs.map(p => `- [${p.confidence}★] [${this.typeLabels[p.type] || p.type}] ${p.text}`).join('\n')}`;
+        }
+        return result.trim();
+    }
+    async loadPreferences() {
+        try {
+            await fs.access(this.preferenceFilePath);
+            const content = await fs.readFile(this.preferenceFilePath, 'utf-8');
+            this.preferences = this.parsePreferencesFromMarkdown(content);
+            console.log(`[MemoryManager] 📂 已加载 ${this.preferences.length} 条偏好记忆`);
+        }
+        catch {
+            console.log('[MemoryManager] 📝 user_preferences.md 不存在，将创建新文件');
+            this.preferences = [];
+            await this.writePreferences();
+        }
+    }
+    async writePreferences() {
+        const now = new Date().toISOString().replace('T', ' ').substring(0, 19);
+        const header = this.fileHeader.replace('{{lastUpdated}}', now);
+        const body = this.formatPreferencesToMarkdown();
+        const content = header + body;
+        const tmpPath = this.preferenceFilePath + '.tmp';
+        try {
+            await fs.writeFile(tmpPath, content, 'utf-8');
+            await fs.rename(tmpPath, this.preferenceFilePath);
+        }
+        catch (error) {
+            console.error('[MemoryManager] ❌ 写入偏好文件失败:', error);
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    formatPreferencesToMarkdown() {
+        if (this.preferences.length === 0) {
+            return `*暂无记录的用户偏好。当你在对话中表达偏好、习惯或决定时，我会自动记录在这里。*\n`;
+        }
+        const groups = {};
+        for (const pref of this.preferences) {
+            if (!groups[pref.type])
+                groups[pref.type] = [];
+            groups[pref.type].push(pref);
+        }
+        const typeOrder = ['preference', 'habit', 'fact', 'decision'];
+        const sortedTypes = Object.keys(groups).sort((a, b) => typeOrder.indexOf(a) - typeOrder.indexOf(b));
+        let markdown = '';
+        markdown += `## 📊 统计\n\n`;
+        markdown += `- **总计**：${this.preferences.length} 条记忆\n`;
+        for (const type of sortedTypes) {
+            const label = this.typeLabels[type] || type;
+            markdown += `- **${label}**：${groups[type].length} 条\n`;
+        }
+        markdown += '\n---\n\n';
+        for (const type of sortedTypes) {
+            const label = this.typeLabels[type] || type;
+            const emoji = this.getTypeEmoji(type);
+            markdown += `## ${emoji} ${label}\n\n`;
+            for (const pref of groups[type]) {
+                const stars = '★'.repeat(pref.confidence) + '☆'.repeat(5 - pref.confidence);
+                markdown += `- [${stars}] ${pref.text}\n`;
+            }
+            markdown += '\n';
+        }
+        return markdown;
+    }
+    parsePreferencesFromMarkdown(content) {
+        const preferences = [];
+        const lines = content.split('\n');
+        let currentType = null;
+        for (const line of lines) {
+            const typeMatch = line.match(/^##\s+(?:[^\s]+\s+)?(.+)$/);
+            if (typeMatch) {
+                const headingText = typeMatch[1].trim();
+                for (const [key, label] of Object.entries(this.typeLabels)) {
+                    if (headingText === label) {
+                        currentType = key;
+                        break;
+                    }
+                }
+                continue;
+            }
+            if (line.startsWith('## 📊') || line.startsWith('---') || line.startsWith('>')) {
+                currentType = null;
+                continue;
+            }
+            if (currentType && line.trim().startsWith('- ')) {
+                const text = line.trim().substring(2).trim();
+                if (text && !text.includes('*暂无') && !text.includes('**总计**') && !text.startsWith('**')) {
+                    const starMatch = text.match(/\[(★+)(☆+)?\]/);
+                    const confidence = starMatch ? starMatch[1].length : 1;
+                    const cleanText = text.replace(/\[[★☆]+\]\s*/, '');
+                    preferences.push({
+                        text: cleanText,
+                        type: currentType,
+                        source: 'user_preferences.md',
+                        confidence,
+                        occurrences: confidence,
+                        lastMentioned: Date.now()
+                    });
+                }
+            }
+        }
+        return preferences;
+    }
+    getTypeEmoji(type) {
+        const emojis = {
+            preference: '🎯',
+            habit: '🔄',
+            fact: '📋',
+            decision: '✅'
+        };
+        return emojis[type] || '📌';
+    }
+}
+//# sourceMappingURL=memory-manager.js.map

package/dist/payment.js

@@ -0,0 +1,89 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+const ACTIVATION_FILE = 'payment.json';
+export function getActivationPath(basePath) {
+    return path.join(basePath, ACTIVATION_FILE);
+}
+export async function loadActivation(basePath) {
+    const filePath = getActivationPath(basePath);
+    try {
+        const data = await fs.readFile(filePath, 'utf-8');
+        const parsed = JSON.parse(data);
+        if (!parsed.deviceId) {
+            parsed.deviceId = generateDeviceId();
+            await fs.writeFile(filePath, JSON.stringify(parsed, null, 2), 'utf-8');
+        }
+        return parsed;
+    }
+    catch {
+        const state = {
+            plan: 'free',
+            license: null,
+            activatedAt: null,
+            expiresAt: null,
+            deviceId: generateDeviceId(),
+            email: null,
+        };
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf-8');
+        return state;
+    }
+}
+export async function saveActivation(basePath, state) {
+    const filePath = getActivationPath(basePath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf-8');
+}
+export async function activateLicense(basePath, license, serverUrl) {
+    const res = await fetch(`${serverUrl}/api/license/verify`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ license }),
+    });
+    if (!res.ok)
+        throw new Error('许可证无效或已过期');
+    const data = await res.json();
+    const state = {
+        plan: data.plan,
+        license,
+        activatedAt: new Date().toISOString(),
+        expiresAt: data.expiresAt,
+        deviceId: generateDeviceId(),
+        email: data.email || null,
+    };
+    await saveActivation(basePath, state);
+    return state;
+}
+export async function createPaymentOrder(plan, serverUrl) {
+    const state = await loadActivation('');
+    const res = await fetch(`${serverUrl}/api/payment/create-order`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${state.license}`,
+        },
+        body: JSON.stringify({ plan }),
+    });
+    if (!res.ok)
+        throw new Error('创建订单失败');
+    return res.json();
+}
+export async function checkPaymentStatus(orderId, serverUrl) {
+    const state = await loadActivation('');
+    const res = await fetch(`${serverUrl}/api/payment/order/${orderId}`, {
+        headers: { 'Authorization': `Bearer ${state.license}` },
+    });
+    if (!res.ok)
+        return 'unknown';
+    const data = await res.json();
+    return data.status;
+}
+function generateDeviceId() {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let id = '';
+    for (let i = 0; i < 16; i++) {
+        id += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return id;
+}
+//# sourceMappingURL=payment.js.map

package/dist/preference-extractor.js

@@ -0,0 +1,190 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * 用户偏好提取器
+ * 职责：只负责从对话文本中提取结构化的偏好数据。
+ * 不负责存储——存储逻辑交给 MemoryManager 处理。
+ * 模型自动识别：环境变量 > openclaw.json > 自动探测 LLM 服务端 > 兜底。
+ */
+export class PreferenceExtractor {
+    llmModel = '';
+    llmUrl;
+    // 触发偏好提取的关键词
+    triggerKeywords = [
+        '喜欢', '讨厌', '习惯', '以后', '记住', '不要',
+        '总是', '用这个', '改成', '偏好', '我不喜欢',
+        '下次', '每次都', '一直用', '改一下'
+    ];
+    constructor(llmUrl = 'http://127.0.0.1:1234/v1') {
+        this.llmUrl = llmUrl;
+        // 异步初始化模型名称，不阻塞构造函数
+        this.resolveModel().then(model => {
+            this.llmModel = model;
+        });
+    }
+    /**
+     * 从对话中提取用户偏好
+     * @param userMessage 用户的最新消息
+     * @param agentMessage Agent 对应的回复
+     * @returns 提取到的偏好列表，如果没有偏好则返回空数组
+     */
+    async extract(userMessage, agentMessage) {
+        // 1. 关键词预过滤：避免无意义的 LLM 调用
+        const hasTrigger = this.triggerKeywords.some(keyword => userMessage.includes(keyword));
+        if (!hasTrigger)
+            return [];
+        // 2. 确保模型已经初始化
+        if (!this.llmModel) {
+            await this.resolveModel();
+        }
+        console.log('[PreferenceExtractor] 🔍 检测到潜在的偏好表达，正在分析...');
+        // 3. 构造提取 Prompt
+        const prompt = this.buildExtractionPrompt(userMessage, agentMessage);
+        try {
+            const response = await this.callLLM(prompt);
+            const preferences = this.parseResponse(response);
+            return preferences;
+        }
+        catch (error) {
+            console.error('[PreferenceExtractor] ❌ 偏好提取失败:', error);
+            return [];
+        }
+    }
+    /**
+     * 批量提取：从一整天的对话日志中提取所有偏好
+     * @param conversationText 一整天的对话文本
+     * @returns 提取到的偏好列表
+     */
+    async extractBatch(conversationText) {
+        if (!this.llmModel) {
+            await this.resolveModel();
+        }
+        const prompt = `分析以下对话，从中提取所有重要的用户偏好、习惯和事实。
+以 JSON 列表格式返回，每条记忆包含三个字段：
+- text: 记忆内容（一句话）
+- type: 类型，可选值：preference（偏好）、habit（习惯）、fact（事实）、decision（决定）
+- source: 来源（对话摘要）
+
+对话内容：
+${conversationText}
+
+只返回 JSON 列表，不要其他内容：`;
+        try {
+            const response = await this.callLLM(prompt);
+            return this.parseResponse(response);
+        }
+        catch {
+            return [];
+        }
+    }
+    // ========== 私有方法 ==========
+    /**
+     * 智能获取可用的模型名称
+     * 优先级：环境变量 > openclaw.json > 自动探测 LLM 服务端 > 兜底
+     */
+    async resolveModel() {
+        // 1. 环境变量（最高优先级，用户手动指定）
+        if (process.env.SELF_GROWTH_LLM_MODEL) {
+            this.llmModel = process.env.SELF_GROWTH_LLM_MODEL;
+            return this.llmModel;
+        }
+        // 2. 读取 openclaw.json 中的 primary 模型
+        try {
+            const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(configContent);
+            const primaryModel = config?.agents?.defaults?.model?.primary;
+            if (primaryModel) {
+                this.llmModel = primaryModel;
+                return this.llmModel;
+            }
+        }
+        catch {
+            // 配置文件不存在或读取失败，静默跳过
+        }
+        // 3. 探测 llmUrl 的 /models 端点
+        // 兼容任何 OpenAI 兼容服务：LM Studio、Ollama、vLLM、text-generation-webui 等
+        try {
+            const response = await fetch(`${this.llmUrl}/models`);
+            const data = await response.json();
+            // 不同服务返回的字段名可能不同，逐个尝试
+            const firstModel = data?.data?.[0]?.id // LM Studio / Ollama 格式
+                || data?.models?.[0]?.name // vLLM 格式
+                || data?.models?.[0]?.id // 其他格式
+                || data?.data?.[0]?.name;
+            if (firstModel) {
+                this.llmModel = firstModel;
+                return this.llmModel;
+            }
+        }
+        catch {
+            // 服务端不在线或 /models 端点不可用，跳过
+        }
+        // 4. 最终兜底
+        this.llmModel = 'default-model';
+        return this.llmModel;
+    }
+    /**
+     * 构建发送给 LLM 的分析 Prompt
+     */
+    buildExtractionPrompt(userMessage, agentMessage) {
+        return `你是一个专业的用户偏好分析助手。请分析以下对话，判断用户是否表达了需要长期记忆的"个人偏好"或"习惯"。
+
+【对话内容】
+用户: ${userMessage}
+Agent: ${agentMessage}
+
+【判断标准】
+1. 必须是针对未来交互的通用要求（例如："以后写代码都用中文变量名"、"我不喜欢看长篇大论"）。
+2. 如果是针对当前任务的临时指令（例如："把这句话翻译成英文"），则忽略。
+3. 如果确认是长期偏好，请用 JSON 格式返回，包含 text（一句话精炼总结）、type（preference/habit/fact/decision）、source（"对话记录"）。
+4. 如果不是，请返回空列表 []。
+
+【你的结论】`;
+    }
+    /**
+     * 调用 LLM API（兼容任何 OpenAI 兼容服务端）
+     */
+    async callLLM(prompt) {
+        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.1,
+                    max_tokens: 2000
+                })
+            });
+            const data = await response.json();
+            return data.choices?.[0]?.message?.content || '[]';
+        }
+        catch (error) {
+            console.error('[PreferenceExtractor] LLM 调用失败:', error);
+            return '[]';
+        }
+    }
+    /**
+     * 解析 LLM 返回的 JSON 响应
+     * 能处理纯 JSON、JSON 数组、以及嵌在文本中的 JSON
+     */
+    parseResponse(response) {
+        try {
+            return JSON.parse(response);
+        }
+        catch {
+            const match = response.match(/\[[\s\S]*\]/);
+            if (match) {
+                try {
+                    return JSON.parse(match[0]);
+                }
+                catch {
+                    // 解析失败，返回空
+                }
+            }
+        }
+        return [];
+    }
+}
+//# sourceMappingURL=preference-extractor.js.map