evolcore 0.0.28 → 0.0.29

package/dist/core/memory/index-manager.js

@@ -0,0 +1,308 @@
+/**
+ * index-manager.ts — MEMORY.md 索引管理（v3）
+ *
+ * 负责：
+ *  1. 重建索引：扫描 consolidated/，逐份验签，按 tags 筛选，截断到 indexMaxBytes
+ *  2. 追加条目：单条写入时的快速路径（写入后仍以 rebuild 为准）
+ *
+ * 排序与超期判断一律读**文件 mtime**；frontmatter 的 updatedAt 只作可读信息。
+ *
+ * 索引行格式：`- 20261005 [slug] — 描述 [tag1,tag2]`
+ *   slug 即文件名（consolidated/<slug>.md），不再重复写路径。
+ *
+ * 验签规则（v3 收紧）：只认 `verified`。
+ *   - `invalid`（签名不符）→ 移入 archive/invalid/，不进索引
+ *   - `unsigned`（没有签名块）→ 同样移入 archive/invalid/，不进索引
+ * 主会话和整理会话都写不到 consolidated/（create 由程序签名），出现未签名文件
+ * 说明有人绕过写入通道直接落盘。
+ */
+import fs from 'fs';
+import path from 'path';
+import { getMemoryArray, getMemoryString, parseMemoryDocument } from './memory-document.js';
+/** 索引容量上限（字节）。实际取值由调用方从 memory.indexMaxBytes 传入。 */
+export const DEFAULT_INDEX_MAX_BYTES = 5 * 1024;
+/** Fast metadata index for consolidation candidate scans. */
+export const MEMORY_META_VERSION = 1;
+export const MEMORY_META_FILENAME = '_meta.json';
+function metaPath(memoryDir) {
+    return path.join(memoryDir, MEMORY_META_FILENAME);
+}
+export function refreshMemoryMeta(memoryDir, now = Date.now()) {
+    try {
+        const consolidatedDir = path.join(memoryDir, 'consolidated');
+        const meta = {
+            v: MEMORY_META_VERSION,
+            updatedAt: now,
+            count: 0,
+            hasToGeneralize: false,
+            hasToPromote: false,
+            profileSlug: null,
+            profileMtimeMs: null,
+            oldestMtimeMs: null,
+        };
+        if (fs.existsSync(consolidatedDir)) {
+            for (const f of fs.readdirSync(consolidatedDir)) {
+                if (!f.endsWith('.md'))
+                    continue;
+                const fp = path.join(consolidatedDir, f);
+                let content;
+                let mtimeMs;
+                try {
+                    content = fs.readFileSync(fp, 'utf-8');
+                    mtimeMs = fs.statSync(fp).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                meta.count++;
+                if (meta.oldestMtimeMs === null || mtimeMs < meta.oldestMtimeMs)
+                    meta.oldestMtimeMs = mtimeMs;
+                const tags = getMemoryArray(parseMemoryDocument(content), 'tags');
+                if (tags.includes('to-generalize'))
+                    meta.hasToGeneralize = true;
+                if (tags.includes('to-promote'))
+                    meta.hasToPromote = true;
+                if (tags.includes('profile')) {
+                    meta.profileSlug = f.replace(/\.md$/, '');
+                    meta.profileMtimeMs = mtimeMs;
+                }
+            }
+        }
+        fs.mkdirSync(memoryDir, { recursive: true });
+        const tmp = `${metaPath(memoryDir)}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(meta), 'utf-8');
+        fs.renameSync(tmp, metaPath(memoryDir));
+    }
+    catch { /* metadata is an optimization and never blocks writes */ }
+}
+export function readMemoryMeta(memoryDir) {
+    try {
+        const p = metaPath(memoryDir);
+        if (!fs.existsSync(p))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        if (!parsed || parsed.v !== MEMORY_META_VERSION)
+            return null;
+        if (typeof parsed.count !== 'number')
+            return null;
+        if (typeof parsed.hasToGeneralize !== 'boolean' || typeof parsed.hasToPromote !== 'boolean')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function removeMemoryMeta(memoryDir) {
+    try {
+        fs.rmSync(metaPath(memoryDir), { force: true });
+    }
+    catch { /* ignore */ }
+}
+/**
+ * 必进索引、不被大小截断的标签。
+ *
+ * 注意「永不淘汰」**只指不会被索引的 indexMaxBytes 截断**——只要这条记忆还在，
+ * 就保证出现在索引里。它**不代表免于遗忘审查**：打了这些标签的记忆照样会进
+ * 遗忘候选、照样会被归档。遗忘审查的是「内容还成不成立」，与「在不在索引里」是两个维度。
+ */
+const PINNED_TAGS = ['important', 'urgent', 'profile'];
+/** 任务态标签，排在其后 */
+const ACTIVE_STATE_TAGS = ['in-progress', 'pending', 'blocked'];
+/** 不进索引的状态 */
+const EXCLUDED_TAGS = ['done', 'cancelled'];
+// ── 解析索引行 ──────────────────────────────────────────────────────────────
+/**
+ * 解析索引行，支持两种格式：
+ *   新格式：- 20261005 [slug] — 描述 [tag1,tag2]
+ *   旧格式：- [描述](consolidated/<slug>.md) #kw1 #kw2
+ */
+function parseIndexLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('---') || trimmed.startsWith('#'))
+        return null;
+    // 新格式：- 20261005 [slug] — 描述 [tag1,tag2]
+    const newFmt = trimmed.match(/^-\s+(\d{8})\s+\[([^\]]+)\]\s+—\s+(.+?)(?:\s+\[([^\]]*)\])?$/);
+    if (newFmt) {
+        const tags = newFmt[4] ? newFmt[4].split(',').map(t => t.trim()).filter(Boolean) : [];
+        return { slug: newFmt[2].trim(), description: newFmt[3].trim(), tags };
+    }
+    // 旧格式（兼容）：- [描述](consolidated/xxx.md) #kw1 #kw2
+    const md = trimmed.match(/^-\s*\[([^\]]*)\]\(consolidated\/([^)]+?)\.md\)\s*(#.*)?$/);
+    if (md) {
+        const tags = (md[3] ?? '').split(/\s+/)
+            .map(t => t.replace(/^#/, '').trim())
+            .filter(Boolean);
+        return { slug: md[2].trim(), description: md[1].trim(), tags };
+    }
+    // 极旧格式：[path] | 描述 | #tag1 #tag2
+    const legacy = trimmed.match(/^\[([^\]]+)\]\s*\|\s*(.*?)(?:\s*\|\s*(#.*))?$/);
+    if (legacy) {
+        const tags = (legacy[3] ?? '').split(/\s+/)
+            .map(t => t.replace(/^#/, '').trim())
+            .filter(Boolean);
+        const slug = legacy[1].trim().replace(/^consolidated\//, '').replace(/\.md$/, '');
+        return { slug, description: legacy[2].trim(), tags };
+    }
+    return null;
+}
+function serializeIndex(scope, entries) {
+    const now = new Date().toISOString();
+    const lines = [
+        '---',
+        `scope: ${scope}`,
+        `consolidated: ./consolidated/`,
+        `updatedAt: ${now}`,
+        '---',
+        '',
+    ];
+    for (const e of entries) {
+        // 格式：- 20261005 [slug] — 描述 [tag1,tag2]
+        const dateStr = e.mtimeMs
+            ? new Date(e.mtimeMs).toISOString().slice(0, 10).replace(/-/g, '')
+            : new Date().toISOString().slice(0, 10).replace(/-/g, '');
+        const tagStr = e.tags.length > 0 ? ` [${e.tags.join(',')}]` : '';
+        lines.push(`- ${dateStr} [${e.slug}] — ${e.description}${tagStr}`);
+    }
+    if (entries.length === 0)
+        lines.push('（暂无正式记忆）');
+    lines.push('');
+    return lines.join('\n');
+}
+// ── 排序 ────────────────────────────────────────────────────────────────────
+/** 分类权重，越小越靠前。 */
+function rankOf(tags) {
+    if (tags.some(t => PINNED_TAGS.includes(t)))
+        return 0;
+    if (tags.some(t => ACTIVE_STATE_TAGS.includes(t)))
+        return 1;
+    if (tags.includes('long-term'))
+        return 2;
+    return 3;
+}
+/**
+ * 排序：权重升序，同权重按 mtime 降序（新的在前）。
+ * 不做稳定性依赖——mtime 相同时按路径排，保证结果可复现。
+ */
+function sortEntries(entries) {
+    entries.sort((a, b) => {
+        const ra = rankOf(a.tags);
+        const rb = rankOf(b.tags);
+        if (ra !== rb)
+            return ra - rb;
+        const ma = a.mtimeMs ?? 0;
+        const mb = b.mtimeMs ?? 0;
+        if (ma !== mb)
+            return mb - ma;
+        return a.slug.localeCompare(b.slug);
+    });
+}
+/** 按上限截断（保留权重高的），返回被保留的条目。 */
+function truncateToLimit(scope, entries, maxBytes) {
+    let kept = [...entries];
+    while (kept.length > 0) {
+        const serialized = serializeIndex(scope, kept);
+        if (Buffer.byteLength(serialized, 'utf-8') <= maxBytes)
+            return kept;
+        // 从末尾（权重最低、最旧）移除
+        kept = kept.slice(0, -1);
+    }
+    return [];
+}
+// ── 读取 frontmatter ────────────────────────────────────────────────────────
+// ── 追加条目（写入后的快速路径） ────────────────────────────────────────────
+/**
+ * 向 MEMORY.md 追加（或更新）一条条目。超出上限时按权重截断。
+ * 注意：这不做验签，调用方应保证 entry 来自刚写入的已签名文件。
+ * 整理会话产生多条记忆时，应在会话结束后统一 rebuildIndex。
+ */
+export function appendToIndex(indexPath, entry, scope, indexMaxBytes = DEFAULT_INDEX_MAX_BYTES) {
+    const existing = readIndexEntries(indexPath);
+    const idx = existing.findIndex(e => e.slug === entry.slug);
+    const merged = { ...entry, mtimeMs: Date.now() };
+    if (idx >= 0)
+        existing[idx] = merged;
+    else
+        existing.push(merged);
+    const filtered = existing.filter(e => !e.tags.some(t => EXCLUDED_TAGS.includes(t)));
+    sortEntries(filtered);
+    const kept = truncateToLimit(scope, filtered, indexMaxBytes);
+    writeIndexFile(indexPath, serializeIndex(scope, kept));
+}
+function readIndexEntries(indexPath) {
+    if (!fs.existsSync(indexPath))
+        return [];
+    try {
+        return fs.readFileSync(indexPath, 'utf-8')
+            .split('\n')
+            .map(parseIndexLine)
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+function writeIndexFile(indexPath, content) {
+    const tmp = indexPath + '.tmp';
+    fs.writeFileSync(tmp, content, 'utf-8');
+    fs.renameSync(tmp, indexPath);
+}
+// ── 重建索引 ────────────────────────────────────────────────────────────────
+/**
+ * 从 consolidated/ 重建 MEMORY.md。
+ *
+ * verifyFn 可选。不传时所有文件视为通过，直接进索引，不移动任何文件。
+ * 传入时验签失败的文件只跳过（不进索引），同样不移动文件——移动行为是验签门控
+ * 开启后才需要的，暂未实现。排序读文件 mtime，按 tags 分级，超 indexMaxBytes
+ * 从末尾截断（pinned 标签保留）。
+ */
+export async function rebuildIndex(consolidatedDir, indexPath, scope, invalidDir, verifyFn, indexMaxBytes = DEFAULT_INDEX_MAX_BYTES) {
+    if (!fs.existsSync(consolidatedDir)) {
+        writeIndexFile(indexPath, serializeIndex(scope, []));
+        return { indexed: 0, invalidMoved: 0, verifiedFiles: [] };
+    }
+    const files = fs.readdirSync(consolidatedDir).filter(f => f.endsWith('.md')).sort();
+    const entries = [];
+    const verifiedFiles = [];
+    for (const file of files) {
+        const filePath = path.join(consolidatedDir, file);
+        let content;
+        let mtimeMs;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+            mtimeMs = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            continue;
+        }
+        if (verifyFn) {
+            const verifyResult = await verifyFn(content);
+            if (verifyResult.status === 'verified') {
+                verifiedFiles.push(file);
+            }
+            else {
+                // 验签失败：跳过，不进索引，不移动文件（门控开启后的移动逻辑暂未实现）
+                continue;
+            }
+        }
+        else {
+            // 未开启验签：所有文件视为通过
+            verifiedFiles.push(file);
+        }
+        const document = parseMemoryDocument(content);
+        const description = getMemoryString(document, 'description') ?? file.replace(/\.md$/, '');
+        const tags = getMemoryArray(document, 'tags');
+        if (tags.some(t => EXCLUDED_TAGS.includes(t)))
+            continue;
+        entries.push({
+            slug: file.replace(/\.md$/, ''),
+            description,
+            tags,
+            mtimeMs,
+        });
+    }
+    sortEntries(entries);
+    const kept = truncateToLimit(scope, entries, indexMaxBytes);
+    writeIndexFile(indexPath, serializeIndex(scope, kept));
+    return { indexed: kept.length, invalidMoved: 0, verifiedFiles };
+}