openclaw-cortex-memory 0.1.0-Alpha.30 → 0.1.0-Alpha.32

package/dist/src/wiki/wiki_projector.js

@@ -0,0 +1,633 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeGraphViewProjection = writeGraphViewProjection;
+exports.projectWikiKnowledge = projectWikiKnowledge;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+function slugify(value) {
+    const normalized = (value || "").trim().toLowerCase();
+    if (!normalized)
+        return "unknown";
+    return normalized.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "unknown";
+}
+function sortByString(items, getter) {
+    return [...items].sort((a, b) => getter(a).localeCompare(getter(b)));
+}
+function readJsonl(filePath) {
+    if (!fs.existsSync(filePath))
+        return [];
+    const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean);
+    const output = [];
+    for (const line of lines) {
+        try {
+            output.push(JSON.parse(line));
+        }
+        catch {
+            // ignore malformed lines
+        }
+    }
+    return output;
+}
+function normalizeKey(value) {
+    return String(value || "").trim().toLowerCase();
+}
+function toIso(raw, fallback) {
+    const ms = Date.parse(raw || "");
+    return Number.isFinite(ms) ? new Date(ms).toISOString() : fallback;
+}
+function relationKey(source, type, target) {
+    return `${normalizeKey(source)}|${normalizeKey(type)}|${normalizeKey(target)}`;
+}
+function relationEventKey(relKey, sourceEventId) {
+    return `${normalizeKey(relKey)}|${normalizeKey(sourceEventId)}`;
+}
+function conflictRelationKey(conflictId, relKey) {
+    return `${normalizeKey(conflictId)}|${normalizeKey(relKey)}`;
+}
+function entityTypeLookup(types) {
+    const output = new Map();
+    for (const [name, type] of Object.entries(types || {})) {
+        const key = normalizeKey(name);
+        const value = String(type || "").trim();
+        if (key && value) {
+            output.set(key, value);
+        }
+    }
+    return output;
+}
+function sanitizeInline(value, fallback = "n/a") {
+    const text = String(value || "").trim().replace(/\s+/g, " ");
+    return text || fallback;
+}
+function writeGraphViewProjection(args) {
+    const graphDir = path.join(args.memoryRoot, "wiki", "graph");
+    const viewPath = path.join(graphDir, "view.json");
+    const timelinePath = path.join(graphDir, "timeline.jsonl");
+    const nowIso = new Date().toISOString();
+    const snapshotId = `gview_${Date.now().toString(36)}`;
+    ensureDir(graphDir);
+    const viewPayload = {
+        ...args.view,
+        generated_at: nowIso,
+        snapshot_id: snapshotId,
+    };
+    fs.writeFileSync(viewPath, `${JSON.stringify(viewPayload, null, 2)}\n`, "utf-8");
+    const timelineEntry = {
+        snapshot_id: snapshotId,
+        generated_at: nowIso,
+        graph_updated_at: args.view.updated_at,
+        nodes: args.view.nodes.length,
+        edges: args.view.edges.length,
+        status_counts: args.view.status_counts,
+    };
+    fs.appendFileSync(timelinePath, `${JSON.stringify(timelineEntry)}\n`, "utf-8");
+    return {
+        view_path: viewPath,
+        timeline_path: timelinePath,
+        snapshot_id: snapshotId,
+    };
+}
+function relationCluster(typeRaw) {
+    const type = normalizeKey(typeRaw);
+    if (type === "resolves" || type === "solved_with")
+        return "resolution";
+    if (type === "plans_to" || type === "planned_for" || type === "scheduled_for")
+        return "planning";
+    return type;
+}
+function normalizeForSimilarity(value) {
+    return value.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function overlapRatio(left, right) {
+    const a = new Set(normalizeForSimilarity(left).split(" ").filter(token => token.length >= 2));
+    const b = new Set(normalizeForSimilarity(right).split(" ").filter(token => token.length >= 2));
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let hit = 0;
+    for (const token of a) {
+        if (b.has(token))
+            hit += 1;
+    }
+    return hit / Math.max(1, Math.min(a.size, b.size));
+}
+function diceSimilarity(leftRaw, rightRaw) {
+    const left = normalizeForSimilarity(leftRaw).replace(/\s+/g, "");
+    const right = normalizeForSimilarity(rightRaw).replace(/\s+/g, "");
+    if (!left || !right)
+        return 0;
+    if (left === right)
+        return 1;
+    const grams = (value) => {
+        if (value.length < 2)
+            return [value];
+        const out = [];
+        for (let i = 0; i < value.length - 1; i += 1) {
+            out.push(value.slice(i, i + 2));
+        }
+        return out;
+    };
+    const lg = grams(left);
+    const rg = grams(right);
+    const bag = new Map();
+    for (const gram of rg) {
+        bag.set(gram, (bag.get(gram) || 0) + 1);
+    }
+    let matches = 0;
+    for (const gram of lg) {
+        const remain = bag.get(gram) || 0;
+        if (remain > 0) {
+            matches += 1;
+            bag.set(gram, remain - 1);
+        }
+    }
+    return (2 * matches) / (lg.length + rg.length);
+}
+function withinDays(leftIso, rightIso, days) {
+    const left = Date.parse(leftIso);
+    const right = Date.parse(rightIso);
+    if (!Number.isFinite(left) || !Number.isFinite(right))
+        return false;
+    return Math.abs(left - right) <= days * 24 * 60 * 60 * 1000;
+}
+function buildProjectedRelations(args) {
+    const nowIso = new Date().toISOString();
+    const records = readJsonl(path.join(args.memoryRoot, "graph", "memory.jsonl"));
+    const conflicts = readJsonl(path.join(args.memoryRoot, "graph", "conflict_queue.jsonl"));
+    const superseded = readJsonl(path.join(args.memoryRoot, "graph", "superseded_relations.jsonl"));
+    const byEvent = new Map();
+    const byRelation = new Map();
+    const byConflict = new Map();
+    const conflictUpdatedAt = new Map();
+    const supersededByRelation = new Map();
+    const supersededByComposite = new Map();
+    const upsert = (target, key, next) => {
+        const prev = target.get(key);
+        if (!prev) {
+            target.set(key, next);
+            return;
+        }
+        const prevMs = Date.parse(prev.timestamp || "");
+        const nextMs = Date.parse(next.timestamp || "");
+        if (!Number.isFinite(prevMs) || (Number.isFinite(nextMs) && nextMs >= prevMs)) {
+            target.set(key, next);
+        }
+    };
+    for (const record of records) {
+        const sourceEventId = String(record.source_event_id || "").trim();
+        const timestamp = toIso(record.timestamp, nowIso);
+        const typeMap = entityTypeLookup(record.entity_types);
+        for (const rel of record.relations || []) {
+            const source = String(rel.source || "").trim();
+            const target = String(rel.target || "").trim();
+            const type = String(rel.type || "").trim().toLowerCase();
+            if (!source || !target || !type)
+                continue;
+            const key = relationKey(source, type, target);
+            const detail = {
+                source_event_id: sourceEventId || undefined,
+                source_layer: record.source_layer,
+                source_file: record.source_file,
+                timestamp,
+                summary: typeof record.summary === "string" ? record.summary.trim() : undefined,
+                source_text_nav: record.source_text_nav,
+                source_type: typeMap.get(normalizeKey(source)),
+                target_type: typeMap.get(normalizeKey(target)),
+                relation_origin: rel.relation_origin,
+                relation_definition: typeof rel.relation_definition === "string" ? rel.relation_definition.trim() : undefined,
+                evidence_span: typeof rel.evidence_span === "string" ? rel.evidence_span.trim() : undefined,
+                context_chunk: typeof rel.context_chunk === "string" ? rel.context_chunk.trim() : undefined,
+                confidence: typeof rel.confidence === "number" ? rel.confidence : undefined,
+            };
+            if (sourceEventId) {
+                upsert(byEvent, relationEventKey(key, sourceEventId), detail);
+            }
+            upsert(byRelation, key, detail);
+        }
+    }
+    for (const conflict of conflicts) {
+        const conflictId = String(conflict.conflict_id || "").trim();
+        if (!conflictId)
+            continue;
+        const updatedAt = toIso(conflict.updated_at || conflict.created_at, nowIso);
+        conflictUpdatedAt.set(conflictId, updatedAt);
+        const candidate = conflict.candidate || {};
+        const typeMap = entityTypeLookup(candidate.entity_types);
+        for (const rel of candidate.relations || []) {
+            const source = String(rel.source || "").trim();
+            const target = String(rel.target || "").trim();
+            const type = String(rel.type || "").trim().toLowerCase();
+            if (!source || !target || !type)
+                continue;
+            const key = relationKey(source, type, target);
+            byConflict.set(conflictRelationKey(conflictId, key), {
+                source_event_id: typeof conflict.source_event_id === "string" ? conflict.source_event_id.trim() || undefined : undefined,
+                source_layer: conflict.source_layer,
+                source_file: conflict.source_file,
+                timestamp: updatedAt,
+                summary: typeof candidate.summary === "string" ? candidate.summary.trim() : undefined,
+                source_text_nav: candidate.source_text_nav,
+                source_type: typeMap.get(normalizeKey(source)),
+                target_type: typeMap.get(normalizeKey(target)),
+                relation_origin: rel.relation_origin,
+                relation_definition: typeof rel.relation_definition === "string" ? rel.relation_definition.trim() : undefined,
+                evidence_span: typeof rel.evidence_span === "string" ? rel.evidence_span.trim() : undefined,
+                context_chunk: typeof rel.context_chunk === "string" ? rel.context_chunk.trim() : undefined,
+                confidence: typeof rel.confidence === "number" ? rel.confidence : undefined,
+                conflict_id: conflictId,
+            });
+        }
+    }
+    for (const entry of superseded) {
+        const key = normalizeKey(entry.relation_key);
+        if (!key)
+            continue;
+        const at = toIso(entry.superseded_at, nowIso);
+        const conflictId = normalizeKey(entry.conflict_id);
+        supersededByRelation.set(key, at);
+        if (conflictId) {
+            supersededByComposite.set(conflictRelationKey(conflictId, key), at);
+        }
+    }
+    const output = [];
+    for (const edge of args.graphView.edges) {
+        const source = String(edge.source || "").trim();
+        const target = String(edge.target || "").trim();
+        const type = String(edge.type || "").trim().toLowerCase();
+        if (!source || !target || !type)
+            continue;
+        const key = normalizeKey(edge.relation_key) || relationKey(source, type, target);
+        const sourceEventId = typeof edge.source_event_id === "string" ? edge.source_event_id.trim() : "";
+        const conflictId = typeof edge.conflict_id === "string" ? edge.conflict_id.trim() : "";
+        const status = edge.status;
+        let detail;
+        if ((status === "pending_conflict" || status === "rejected") && conflictId) {
+            detail = byConflict.get(conflictRelationKey(conflictId, key));
+        }
+        if (!detail && sourceEventId) {
+            detail = byEvent.get(relationEventKey(key, sourceEventId));
+        }
+        if (!detail) {
+            detail = byRelation.get(key);
+        }
+        let timestamp = detail?.timestamp || nowIso;
+        if (status === "superseded") {
+            timestamp = supersededByComposite.get(conflictRelationKey(conflictId, key)) || supersededByRelation.get(key) || timestamp;
+        }
+        else if ((status === "pending_conflict" || status === "rejected") && conflictId) {
+            timestamp = conflictUpdatedAt.get(conflictId) || timestamp;
+        }
+        output.push({
+            source,
+            target,
+            type,
+            status,
+            relation_key: key,
+            source_event_id: sourceEventId || detail?.source_event_id,
+            conflict_id: conflictId || detail?.conflict_id,
+            timestamp: toIso(timestamp, nowIso),
+            summary: detail?.summary || `${source} ${type} ${target}`,
+            source_text_nav: detail?.source_text_nav,
+            relation_origin: detail?.relation_origin,
+            relation_definition: detail?.relation_definition,
+            evidence_span: detail?.evidence_span || (typeof edge.evidence_span === "string" ? edge.evidence_span : undefined),
+            context_chunk: detail?.context_chunk || (typeof edge.evidence_span === "string" ? edge.evidence_span : undefined),
+            confidence: typeof edge.confidence === "number" ? edge.confidence : detail?.confidence,
+            source_type: detail?.source_type,
+            target_type: detail?.target_type,
+        });
+    }
+    return output.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+}
+function hardMatch(group, relation) {
+    if (group.source_key !== normalizeKey(relation.source))
+        return false;
+    if (group.relation_cluster !== relationCluster(relation.type))
+        return false;
+    const targetKey = normalizeKey(relation.target);
+    const targetClass = normalizeKey(relation.target_type || "");
+    return group.targets.has(targetKey) || (!!group.target_class && !!targetClass && group.target_class === targetClass);
+}
+function softScore(group, relation) {
+    const latest = group.relations[group.relations.length - 1];
+    if (!latest)
+        return 0;
+    let score = 0;
+    if (withinDays(latest.timestamp, relation.timestamp, 30))
+        score += 1;
+    if (overlapRatio(`${latest.evidence_span || ""} ${latest.context_chunk || ""}`, `${relation.evidence_span || ""} ${relation.context_chunk || ""}`) >= 0.2)
+        score += 1;
+    if (diceSimilarity(`${latest.summary || ""} ${latest.context_chunk || ""}`, `${relation.summary || ""} ${relation.context_chunk || ""}`) >= 0.82)
+        score += 1;
+    return score;
+}
+function buildTimelineGroups(relations) {
+    const groups = [];
+    const sorted = [...relations].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+    for (const relation of sorted) {
+        let best = null;
+        let bestScore = -1;
+        for (const group of groups) {
+            if (!hardMatch(group, relation))
+                continue;
+            const score = softScore(group, relation);
+            if (score >= 2 && score > bestScore) {
+                best = group;
+                bestScore = score;
+            }
+        }
+        if (!best) {
+            groups.push({
+                source: relation.source,
+                source_key: normalizeKey(relation.source),
+                relation_type: relation.type,
+                relation_cluster: relationCluster(relation.type),
+                target_class: normalizeKey(relation.target_type || ""),
+                targets: new Set([normalizeKey(relation.target)]),
+                relations: [relation],
+                timeline_id: "",
+            });
+            continue;
+        }
+        best.relations.push(relation);
+        best.targets.add(normalizeKey(relation.target));
+    }
+    const used = new Set();
+    for (const group of groups) {
+        const targetScope = group.targets.size > 1 ? (group.target_class || "multi_target") : (group.relations[0]?.target || "target");
+        const base = slugify(`${group.source}.${targetScope}.${group.relation_type}`);
+        let id = base;
+        let idx = 2;
+        while (used.has(id)) {
+            id = `${base}_${idx}`;
+            idx += 1;
+        }
+        used.add(id);
+        group.timeline_id = id;
+    }
+    return groups.sort((a, b) => a.timeline_id.localeCompare(b.timeline_id));
+}
+function renderRelationLine(relation) {
+    const attrs = [
+        `evidence=${sanitizeInline(relation.evidence_span)}`,
+        `confidence=${typeof relation.confidence === "number" ? relation.confidence : "n/a"}`,
+        `source_event_id=${sanitizeInline(relation.source_event_id)}`,
+    ];
+    if (relation.conflict_id)
+        attrs.push(`conflict_id=${sanitizeInline(relation.conflict_id)}`);
+    if (relation.relation_origin)
+        attrs.push(`relation_origin=${relation.relation_origin}`);
+    if (relation.relation_origin === "llm_custom" && relation.relation_definition) {
+        attrs.push(`relation_definition=${sanitizeInline(relation.relation_definition).replace(/,/g, ";")}`);
+    }
+    return `- ${relation.source} --${relation.type}/${relation.status}--> ${relation.target} (${attrs.join(", ")})`;
+}
+function timelineLines(relations) {
+    if (relations.length === 0)
+        return ["- (none)"];
+    const out = [];
+    for (const relation of [...relations].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp))) {
+        const evidenceIds = [
+            `graph:relation:${relation.relation_key}`,
+            relation.source_event_id ? `graph:event:${relation.source_event_id}` : "",
+            relation.conflict_id ? `graph:conflict:${relation.conflict_id}` : "",
+        ].filter(Boolean).join(", ");
+        out.push(`- ${relation.timestamp} | ${relation.status}`);
+        out.push(`  evidence_ids: ${evidenceIds || "n/a"}`);
+        out.push(`  context_chunk: ${sanitizeInline(relation.context_chunk || relation.evidence_span)}`);
+    }
+    return out;
+}
+function latestStatus(relations) {
+    if (relations.length === 0)
+        return "active";
+    return [...relations].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)).slice(-1)[0].status;
+}
+function sourceRefs(relations) {
+    const dedupe = new Set();
+    const out = [];
+    for (const relation of relations) {
+        const nav = relation.source_text_nav;
+        const line = nav
+            ? `- source_event_id=${sanitizeInline(relation.source_event_id)} | layer=${sanitizeInline(nav.layer)} | source_file=${sanitizeInline(nav.source_file)} | source_memory_id=${sanitizeInline(nav.source_memory_id)}${nav.fulltext_anchor ? ` | fulltext_anchor=${sanitizeInline(nav.fulltext_anchor)}` : ""}`
+            : `- source_event_id=${sanitizeInline(relation.source_event_id)} | fulltext_nav_missing=true`;
+        if (!dedupe.has(line)) {
+            dedupe.add(line);
+            out.push(line);
+        }
+    }
+    return out.length > 0 ? out : ["- (none)"];
+}
+function section(title, lines) {
+    return [`## ${title}`, "", ...(lines.length > 0 ? lines : ["- (none)"]), ""];
+}
+function projectWikiKnowledge(args) {
+    const wikiRoot = path.join(args.memoryRoot, "wiki");
+    const entitiesDir = path.join(wikiRoot, "entities");
+    const topicsDir = path.join(wikiRoot, "topics");
+    const timelinesDir = path.join(wikiRoot, "timelines");
+    const indexPath = path.join(wikiRoot, "index.md");
+    const projectionIndexPath = path.join(wikiRoot, ".projection_index.json");
+    ensureDir(wikiRoot);
+    ensureDir(entitiesDir);
+    ensureDir(topicsDir);
+    ensureDir(timelinesDir);
+    const relations = buildProjectedRelations({
+        memoryRoot: args.memoryRoot,
+        graphView: args.graphView,
+    });
+    const byEntity = new Map();
+    const byTopic = new Map();
+    for (const relation of relations) {
+        for (const entity of [relation.source, relation.target]) {
+            const display = entity.trim();
+            const key = display.toLowerCase();
+            if (!key)
+                continue;
+            if (!byEntity.has(key)) {
+                byEntity.set(key, { display, relations: [] });
+            }
+            byEntity.get(key)?.relations.push(relation);
+        }
+        if (!byTopic.has(relation.type)) {
+            byTopic.set(relation.type, []);
+        }
+        byTopic.get(relation.type)?.push(relation);
+    }
+    const entityEntries = [];
+    const topicEntries = [];
+    const timelineEntries = [];
+    for (const [, value] of sortByString([...byEntity.entries()], item => item[0])) {
+        const entity = value.display;
+        const fileName = `${slugify(entity)}.md`;
+        const filePath = path.join(entitiesDir, fileName);
+        entityEntries.push({ name: entity, file: fileName });
+        const active = value.relations.filter(item => item.status === "active").map(renderRelationLine);
+        const pending = value.relations.filter(item => item.status === "pending_conflict").map(renderRelationLine);
+        const history = value.relations.filter(item => item.status === "superseded" || item.status === "rejected").map(renderRelationLine);
+        const body = [
+            `# Entity: ${entity}`,
+            "",
+            "## Summary",
+            "",
+            `${entity} has ${value.relations.length} related facts in graph projection.`,
+            "",
+            ...section("Current Facts", active),
+            ...section("Disputed Facts", pending),
+            ...section("History", history),
+            ...section("Source References", sourceRefs(value.relations)),
+            "## Updated At",
+            "",
+            `- ${args.graphView.updated_at}`,
+            "",
+        ];
+        fs.writeFileSync(filePath, `${body.join("\n")}\n`, "utf-8");
+    }
+    for (const [topic, topicRelations] of sortByString([...byTopic.entries()], item => item[0])) {
+        const fileName = `${slugify(topic)}.md`;
+        const filePath = path.join(topicsDir, fileName);
+        topicEntries.push({ type: topic, file: fileName });
+        const body = [
+            `# Topic: ${topic}`,
+            "",
+            "## Summary",
+            "",
+            `${topic} has ${topicRelations.length} relations. Latest status is ${latestStatus(topicRelations)}.`,
+            "",
+            ...section("Timeline", timelineLines(topicRelations)),
+            "## Latest Status",
+            "",
+            `- ${latestStatus(topicRelations)}`,
+            "",
+            ...section("Relations", topicRelations.map(renderRelationLine)),
+            ...section("Source References", sourceRefs(topicRelations)),
+            "## Updated At",
+            "",
+            `- ${args.graphView.updated_at}`,
+            "",
+        ];
+        fs.writeFileSync(filePath, `${body.join("\n")}\n`, "utf-8");
+    }
+    const timelineGroups = buildTimelineGroups(relations);
+    for (const group of timelineGroups) {
+        const targetScope = group.targets.size > 1 ? (group.target_class || "multi_target") : (group.relations[0]?.target || "target");
+        const timelineId = `${group.source}.${targetScope}.${group.relation_type}`;
+        const fileName = `${group.timeline_id}.md`;
+        const filePath = path.join(timelinesDir, fileName);
+        const latest = latestStatus(group.relations);
+        timelineEntries.push({
+            id: timelineId,
+            file: fileName,
+            relation_type: group.relation_type,
+            source: group.source,
+            target_scope: targetScope,
+            latest_status: latest,
+        });
+        const body = [
+            `# Timeline: ${timelineId}`,
+            "",
+            "## Summary",
+            "",
+            `${group.source} ${group.relation_type} timeline has ${group.relations.length} entries. Latest status is ${latest}.`,
+            "",
+            ...section("Timeline", timelineLines(group.relations)),
+            "## Latest Status",
+            "",
+            `- ${latest}`,
+            "",
+            ...section("Relations", group.relations.map(renderRelationLine)),
+            ...section("Source References", sourceRefs(group.relations)),
+            "## Updated At",
+            "",
+            `- ${args.graphView.updated_at}`,
+            "",
+        ];
+        fs.writeFileSync(filePath, `${body.join("\n")}\n`, "utf-8");
+    }
+    const indexBody = [
+        "# Memory Wiki Index",
+        "",
+        `Generated at: ${new Date().toISOString()}`,
+        "",
+        "## Entities",
+        "",
+        ...(entityEntries.length > 0 ? entityEntries.map(item => `- [${item.name}](entities/${item.file})`) : ["- (none)"]),
+        "",
+        "## Topics",
+        "",
+        ...(topicEntries.length > 0 ? topicEntries.map(item => `- [${item.type}](topics/${item.file})`) : ["- (none)"]),
+        "",
+        "## Timelines",
+        "",
+        ...(timelineEntries.length > 0 ? timelineEntries.map(item => `- [${item.id}](timelines/${item.file})`) : ["- (none)"]),
+        "",
+    ];
+    fs.writeFileSync(indexPath, `${indexBody.join("\n")}\n`, "utf-8");
+    const projectionIndex = {
+        updated_at: new Date().toISOString(),
+        graph_updated_at: args.graphView.updated_at,
+        entities: entityEntries.map(item => ({ name: item.name, path: `entities/${item.file}` })),
+        topics: topicEntries.map(item => ({ type: item.type, path: `topics/${item.file}` })),
+        timelines: timelineEntries.map(item => ({
+            id: item.id,
+            relation_type: item.relation_type,
+            source: item.source,
+            target_scope: item.target_scope,
+            latest_status: item.latest_status,
+            path: `timelines/${item.file}`,
+        })),
+        queue_events: args.queueEvents.map(item => ({ id: item.id, type: item.type, at: item.at })),
+    };
+    fs.writeFileSync(projectionIndexPath, `${JSON.stringify(projectionIndex, null, 2)}\n`, "utf-8");
+    return {
+        updated_at: projectionIndex.updated_at,
+        entities_count: entityEntries.length,
+        topics_count: topicEntries.length,
+        timelines_count: timelineEntries.length,
+        files: {
+            index: indexPath,
+            projection_index: projectionIndexPath,
+            entities_dir: entitiesDir,
+            topics_dir: topicsDir,
+            timelines_dir: timelinesDir,
+        },
+    };
+}
+//# sourceMappingURL=wiki_projector.js.map