pigpig-agent 1.0.0

package/dist/memory/store.js

@@ -0,0 +1,175 @@
+/**
+ *  优化记忆存储  -- 不能每次都加载所有记忆
+ *  提取有效记忆手段： 文件 xxx.md | RAG
+ *  xxx.md  ---  专门用一个技能文件来教会Agent如何提取有效记忆
+ */
+// ---
+// name: 用户偏好 Typescript
+// description: 用户对Typescript的偏好设置，不喜欢python
+// type: user
+// ---
+import fs from 'node:fs';
+import path from 'node:path';
+import { lintAll, } from './validator.js';
+const MEMORY_DIR = '.memory'; // 默认记忆目录名
+const INDEX_FILE = 'MEMORY.md'; // 默认记忆文件名  === 一个 skill 文件
+const MAX_INDEX_LINES = 200; // 一个索引文件最多200行
+const MAX_FILE_CHARS = 4000; // 单个记忆文件最多4000个字符
+export class MemoryStore {
+    baseDir = '.';
+    constructor(baseDir = '.') {
+        this.baseDir = baseDir;
+    }
+    get memoryDir() {
+        return path.join(this.baseDir, MEMORY_DIR);
+    }
+    get indexPath() {
+        return path.join(this.memoryDir, INDEX_FILE);
+    }
+    init() {
+        if (!fs.existsSync(this.memoryDir)) {
+            fs.mkdirSync(this.memoryDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.indexPath)) {
+            fs.writeFileSync(this.indexPath, '# Memory Index\n', 'utf-8');
+        }
+    }
+    // 将有效记忆保存到文件，文件以 skill 的格式开头，然后拼接有效的记忆内容
+    save(entry) {
+        this.init();
+        const slug = entry.name
+            .toLowerCase()
+            .replace(/[^a-z0-9一-鿿]+/g, '-')
+            .replace(/^-|-$/g, '');
+        const filename = `${entry.type}_${slug}.md`;
+        const filePath = path.join(this.memoryDir, filename);
+        const fileContent = [
+            '---',
+            `name: ${entry.name}`,
+            `description: ${entry.description}`,
+            `type: ${entry.type}`,
+            '---',
+            '',
+            entry.content,
+        ].join('\n');
+        fs.writeFileSync(filePath, fileContent, 'utf-8');
+        this.updateIndex(entry.name, filename, entry.description);
+        return filename;
+    }
+    // 更新索引文件，判断记忆文件中的内容是否超过最大上限，超过则移除最早的条目
+    updateIndex(name, filename, description) {
+        const indexContent = fs.readFileSync(this.indexPath, 'utf-8');
+        const lines = indexContent.split('\n');
+        const existingIdx = lines.findIndex(l => l.includes(`(${filename})`));
+        const newLine = `- [${name}](${filename}) — ${description}`;
+        if (existingIdx >= 0) {
+            lines[existingIdx] = newLine;
+        }
+        else {
+            if (lines.length >= MAX_INDEX_LINES) {
+                console.log(`[memory] 索引已达 ${MAX_INDEX_LINES} 行上限，移除最早的条目`);
+                const firstEntry = lines.findIndex(l => l.startsWith('- '));
+                if (firstEntry >= 0)
+                    lines.splice(firstEntry, 1);
+            }
+            lines.push(newLine);
+        }
+        fs.writeFileSync(this.indexPath, lines.join('\n'), 'utf-8');
+    }
+    // 从记忆文件中读取所有有效记忆
+    list() {
+        this.init();
+        const entries = []; // 记录所有的记忆文件的头部信息
+        const files = fs.readdirSync(this.memoryDir)
+            .filter(f => f.endsWith('.md') && f !== INDEX_FILE);
+        for (const file of files) {
+            const filePath = path.join(this.memoryDir, file);
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const parsed = this.parseFrontmatter(raw);
+            if (parsed) {
+                entries.push({ ...parsed, filePath });
+            }
+        }
+        return entries;
+    }
+    // 拿着关键词在所有的有效记忆文件的头部信息中搜索，返回所有匹配的记忆
+    search(query) {
+        const all = this.list();
+        const keywords = query.toLowerCase().split(/\s+/);
+        return all.filter(entry => {
+            const text = `${entry.name} ${entry.description} ${entry.content}`.toLowerCase();
+            return keywords.some(kw => text.includes(kw));
+        });
+    }
+    // 读取记忆文件中的内容
+    loadIndex() {
+        this.init();
+        const raw = fs.readFileSync(this.indexPath, 'utf-8');
+        return raw.length > MAX_FILE_CHARS ? raw.slice(0, MAX_FILE_CHARS) + '\n...(已截断)' : raw;
+    }
+    // 读取指定记忆文件的内容
+    loadFile(filename) {
+        const filePath = path.join(this.memoryDir, filename);
+        if (!fs.existsSync(filePath))
+            return null;
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return raw.length > MAX_FILE_CHARS ? raw.slice(0, MAX_FILE_CHARS) + '\n...(已截断)' : raw;
+    }
+    delete(filename) {
+        const filePath = path.join(this.memoryDir, filename);
+        if (!fs.existsSync(filePath))
+            return false;
+        fs.unlinkSync(filePath); // 删除记忆文件
+        const indexContent = fs.readFileSync(this.indexPath, 'utf-8');
+        const lines = indexContent.split('\n').filter(l => !l.includes(`(${filename})`));
+        fs.writeFileSync(this.indexPath, lines.join('\n'), 'utf-8');
+        return true;
+    }
+    // 负责将记忆系统中内容提取出来，构建一个提示段落
+    buildPromptSection() {
+        this.init();
+        const index = this.loadIndex();
+        const entries = this.list();
+        if (entries.length === 0) {
+            return '[记忆系统] 当前没有存储任何记忆。你可以使用 memory 工具来保存重要信息。';
+        }
+        const lines = [
+            `[记忆系统] 共 ${entries.length} 条记忆`,
+            '',
+            '记忆索引：',
+            index,
+            '',
+            '记忆使用原则：',
+            '- 记忆是线索，不是事实——使用前先用工具验证 (read_file,grep确认)',
+            '- 不存代码能推导的，git 能查的，文档已经写了的',
+            '- 只存对话中出现的，其他地方推导不出来的信息',
+        ];
+        return lines.join('\n');
+    }
+    // 解析记忆文件中的 frontmatter 部分，提取 name、description、type 等元数据
+    parseFrontmatter(raw) {
+        const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!match)
+            return null;
+        const meta = {};
+        for (const line of match[1].split('\n')) {
+            const idx = line.indexOf(':');
+            if (idx > 0) {
+                meta[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+            }
+        }
+        const validTypes = ['user', 'feedback', 'project', 'reference'];
+        if (!meta.name || !meta.type || !validTypes.includes(meta.type))
+            return null;
+        return {
+            name: meta.name,
+            description: meta.description || '',
+            type: meta.type,
+            content: match[2].trim(),
+        };
+    }
+    // 记忆体检
+    lint() {
+        return lintAll(this.list(), this.baseDir);
+    }
+}

package/dist/memory/validator.js

@@ -0,0 +1,62 @@
+import path from "path";
+import fs from "fs";
+const TTL_BY_TYPE = {
+    user: 365, // 用户偏好
+    feedback: 90, // 纠正反馈
+    project: 30, // 项目决策
+    reference: 14, // 外部资源  
+};
+// 解析内容中的路径
+const PATH_RE = /(?<![\w/])([\w./-]+\.(?:ts|tsx|js|jsx|json|md|mdx|sql|yml|yaml|toml|env|sh|py))/g;
+export function extractPaths(content) {
+    const paths = new Set();
+    for (const match of content.matchAll(PATH_RE)) {
+        paths.add(match[1]);
+    }
+    return Array.from(paths);
+}
+export function validateEntry(entry, baseDir = '.') {
+    const issues = [];
+    // 检查路径是否过期
+    const paths = extractPaths(entry.content);
+    for (const p of paths) {
+        const abs = path.isAbsolute(p) ? p : path.join(baseDir, p);
+        if (!fs.existsSync(abs)) {
+            issues.push({
+                kind: 'stale_path',
+                message: `引用的路径不存在: ${abs}`,
+            });
+        }
+    }
+    // 按类型 TTL 判断长期未用
+    if (entry.lastReadAt) {
+        const staleDays = TTL_BY_TYPE[entry.type] ?? 30;
+        const days = (Date.now() - entry.lastReadAt) / (1000 * 60 * 60 * 24);
+        if (days > staleDays) {
+            issues.push({
+                kind: 'never_used',
+                message: `已 ${Math.floor(days)} 天没被读过，超过 ${entry.type} 类型的 ${staleDays} 天保质期`,
+            });
+        }
+    }
+    return issues;
+}
+export function lintAll(entries, baseDir = '.') {
+    const reports = [];
+    const nameCount = new Map();
+    for (const e of entries) {
+        nameCount.set(e.name, (nameCount.get(e.name) || 0) + 1);
+    }
+    for (const entry of entries) {
+        const issues = validateEntry(entry, baseDir);
+        if ((nameCount.get(entry.name) || 0) > 1) {
+            issues.push({
+                kind: 'duplicate_name',
+                message: `存在 ${nameCount.get(entry.name)} 条同名记忆，可能需要合并`,
+            });
+        }
+        if (issues.length > 0)
+            reports.push({ entry, issues });
+    }
+    return reports;
+}