opencode-fractal-memory 0.2.0

package/dist/mcp/server.js

@@ -0,0 +1,251 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { createSqliteMemoryStore } from "../storage/sqlite";
+import { withMcpLogging, mcpLog } from "./logging";
+import { nodeToPlain, ensureScope, resourceStats } from "./transform";
+let store;
+export async function createMemoryMcpServer(projectDir, globalDbPath) {
+    store = createSqliteMemoryStore(projectDir, globalDbPath);
+    const server = new McpServer({ name: "opencode-fractal-memory", version: "0.1.0" }, { capabilities: { tools: {}, resources: {} } });
+    server.registerTool("memory_search", {
+        description: "Search memory nodes by text, embedding similarity, or BM25 score",
+        inputSchema: {
+            query: z.string().describe("Search query"),
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+            mode: z.enum(["text", "embedding", "bm25"]).optional().default("text").describe("Search mode"),
+            limit: z.number().int().positive().optional().default(50).describe("Max results"),
+        },
+    }, withMcpLogging("memory_search", async (args) => {
+        const q = args.query.trim();
+        if (!q)
+            return { content: [{ type: "text", text: "[]" }] };
+        const scope = args.scope;
+        const limit = args.limit;
+        try {
+            if (args.mode === "text") {
+                const nodes = await store.listNodes(scope);
+                const lower = q.toLowerCase();
+                const results = nodes
+                    .filter(n => (n.label?.toLowerCase().includes(lower)) || n.content.toLowerCase().includes(lower))
+                    .sort((a, b) => b.importance - a.importance)
+                    .slice(0, limit)
+                    .map(n => ({ ...nodeToPlain(n), score: n.importance }));
+                return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+            }
+            if (args.mode === "embedding") {
+                const { generateEmbedding } = await import("../embeddings");
+                const queryEmbedding = await generateEmbedding(q);
+                const nodes = await store.searchByEmbedding(queryEmbedding, limit, { queryText: q });
+                return { content: [{ type: "text", text: JSON.stringify(nodes.map(n => nodeToPlain(n)), null, 2) }] };
+            }
+            if (args.mode === "bm25") {
+                const nodes = await store.listNodes(scope);
+                const terms = q.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter(t => t.length >= 2);
+                if (terms.length === 0)
+                    return { content: [{ type: "text", text: "[]" }] };
+                const scored = nodes.map(n => {
+                    const text = `${n.label ?? ""} ${n.content}`.toLowerCase();
+                    let score = 0;
+                    for (const term of terms) {
+                        const regex = new RegExp(`\\b${term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "gi");
+                        const matches = text.match(regex);
+                        score += matches ? matches.length : 0;
+                    }
+                    return { ...nodeToPlain(n), score };
+                });
+                scored.sort((a, b) => b.score - a.score);
+                return { content: [{ type: "text", text: JSON.stringify(scored.slice(0, limit), null, 2) }] };
+            }
+            return { content: [{ type: "text", text: "[]" }] };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    }));
+    server.registerTool("memory_get", {
+        description: "Get a single memory node by ID",
+        inputSchema: {
+            id: z.string().describe("Node ID"),
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+        },
+    }, withMcpLogging("memory_get", async (args) => {
+        try {
+            const node = await store.getNode(args.id);
+            return { content: [{ type: "text", text: JSON.stringify(nodeToPlain(node), null, 2) }] };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes("not found")) {
+                return { content: [{ type: "text", text: "Node not found" }], isError: true };
+            }
+            return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+        }
+    }));
+    server.registerTool("memory_fetch", {
+        description: "Fetch a memory node by exact label",
+        inputSchema: {
+            label: z.string().describe("Node label"),
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+        },
+    }, withMcpLogging("memory_fetch", async (args) => {
+        try {
+            const node = await store.getNodeByLabel(ensureScope(args.scope), args.label);
+            return { content: [{ type: "text", text: JSON.stringify(nodeToPlain(node), null, 2) }] };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes("not found")) {
+                return { content: [{ type: "text", text: "Node not found" }], isError: true };
+            }
+            return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
+        }
+    }));
+    server.registerTool("memory_list", {
+        description: "List memory nodes with optional filters",
+        inputSchema: {
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+            level: z.number().int().min(0).max(4).optional().describe("Filter by compression level"),
+            type: z.string().optional().describe("Filter by node type (note, event, concept, summary, etc.)"),
+            limit: z.number().int().positive().optional().default(100).describe("Max results"),
+            offset: z.number().int().nonnegative().optional().default(0).describe("Pagination offset"),
+        },
+    }, withMcpLogging("memory_list", async (args) => {
+        try {
+            let nodes = await store.listNodes(args.scope, args.level);
+            if (args.type) {
+                nodes = nodes.filter(n => n.type === args.type);
+            }
+            const total = nodes.length;
+            if (args.offset > 0)
+                nodes = nodes.slice(args.offset);
+            if (args.limit)
+                nodes = nodes.slice(0, args.limit);
+            return {
+                content: [{ type: "text", text: JSON.stringify({ total, nodes: nodes.map(n => nodeToPlain(n)) }, null, 2) }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    }));
+    server.registerTool("memory_stats", {
+        description: "Get memory statistics for a scope",
+        inputSchema: {
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+        },
+    }, withMcpLogging("memory_stats", async (args) => {
+        try {
+            const [stats, nodes] = await Promise.all([
+                store.getFractalStats(args.scope),
+                store.listNodes(args.scope),
+            ]);
+            const total = stats.totalNodes;
+            const avgImportance = total > 0 ? nodes.reduce((s, n) => s + n.importance, 0) / total : 0;
+            const avgUsefulness = total > 0 ? nodes.reduce((s, n) => s + (n.usefulnessScore ?? 0), 0) / total : 0;
+            const stickyCount = nodes.filter(n => n.sticky).length;
+            const types = {};
+            for (const n of nodes) {
+                const t = n.type ?? "unknown";
+                types[t] = (types[t] ?? 0) + 1;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            scope: args.scope,
+                            totalNodes: total,
+                            nodesPerLevel: stats.nodesPerLevel,
+                            nodesPerType: types,
+                            avgImportance: Math.round(avgImportance * 100) / 100,
+                            avgUsefulness: Math.round(avgUsefulness * 100) / 100,
+                            totalAccessCount: nodes.reduce((s, n) => s + n.accessCount, 0),
+                            stickyCount,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    }));
+    server.registerTool("memory_set", {
+        description: "Create or update a memory node",
+        inputSchema: {
+            label: z.string().describe("Node label (if updating an existing node, provide existing label)"),
+            content: z.string().describe("Node content"),
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+            level: z.number().int().min(0).max(4).optional().default(0).describe("Compression level"),
+            type: z.string().optional().describe("Node type (note, event, concept, summary, etc.)"),
+            importance: z.number().min(0).max(1).optional().default(0.5).describe("Importance score"),
+        },
+    }, withMcpLogging("memory_set", async (args) => {
+        const scope = ensureScope(args.scope);
+        try {
+            const existing = await store.getNodeByLabel(scope, args.label).catch(() => null);
+            if (existing) {
+                await store.updateNode(existing.id, {
+                    content: args.content,
+                    level: args.level,
+                    type: args.type ?? null,
+                    importance: args.importance,
+                });
+                return { content: [{ type: "text", text: JSON.stringify({ success: true, id: existing.id, action: "updated" }) }] };
+            }
+            const node = await store.createNode({
+                scope,
+                label: args.label,
+                content: args.content,
+                level: args.level,
+                type: args.type ?? null,
+                importance: args.importance,
+            });
+            return { content: [{ type: "text", text: JSON.stringify({ success: true, id: node.id, action: "created" }) }] };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    }));
+    server.registerTool("memory_delete", {
+        description: "Delete a memory node by ID",
+        inputSchema: {
+            id: z.string().describe("Node ID to delete"),
+            scope: z.enum(["global", "project"]).optional().default("project").describe("Memory scope"),
+        },
+    }, withMcpLogging("memory_delete", async (args) => {
+        try {
+            const node = await store.getNode(args.id).catch(() => null);
+            if (!node) {
+                return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "Node not found" }) }], isError: true };
+            }
+            await store.deleteNode(args.id);
+            return { content: [{ type: "text", text: JSON.stringify({ success: true, id: args.id, action: "deleted" }) }] };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true,
+            };
+        }
+    }));
+    server.registerResource("Memory Stats (project)", "memory://stats/project", { description: "Memory statistics for project scope" }, async (uri) => {
+        mcpLog("info", "resource:read", { uri: uri.href });
+        return { contents: [{ uri: uri.href, text: await resourceStats("project", store), mimeType: "application/json" }] };
+    });
+    server.registerResource("Memory Stats (global)", "memory://stats/global", { description: "Memory statistics for global scope" }, async (uri) => {
+        mcpLog("info", "resource:read", { uri: uri.href });
+        return { contents: [{ uri: uri.href, text: await resourceStats("global", store), mimeType: "application/json" }] };
+    });
+    return server;
+}

package/dist/mcp/transform.js

@@ -0,0 +1,48 @@
+export function nodeToPlain(n) {
+    return {
+        id: n.id,
+        label: n.label ?? "",
+        content: n.content,
+        summary: n.summary,
+        level: n.level,
+        type: n.type,
+        importance: n.importance,
+        usefulnessScore: n.usefulnessScore,
+        timesUsed: n.timesUsed,
+        timesHelpful: n.timesHelpful,
+        accessCount: n.accessCount,
+        sticky: n.sticky,
+        confidence: n.confidence,
+        createdAt: n.createdAt instanceof Date ? n.createdAt.getTime() : n.createdAt,
+        updatedAt: n.updatedAt instanceof Date ? n.updatedAt.getTime() : n.updatedAt,
+        parentIds: n.parentIds,
+        contentLength: n.content.length,
+        metadata: n.metadata,
+    };
+}
+export function ensureScope(s, defaultScope = "project") {
+    if (s === "global" || s === "project")
+        return s;
+    return defaultScope;
+}
+export async function resourceStats(scope, store) {
+    try {
+        const [stats, nodes] = await Promise.all([
+            store.getFractalStats(scope),
+            store.listNodes(scope),
+        ]);
+        const total = stats.totalNodes;
+        const avgImportance = total > 0 ? nodes.reduce((s, n) => s + n.importance, 0) / total : 0;
+        const avgUsefulness = total > 0 ? nodes.reduce((s, n) => s + (n.usefulnessScore ?? 0), 0) / total : 0;
+        return JSON.stringify({
+            scope,
+            totalNodes: total,
+            nodesPerLevel: stats.nodesPerLevel,
+            avgImportance: Math.round(avgImportance * 100) / 100,
+            avgUsefulness: Math.round(avgUsefulness * 100) / 100,
+        }, null, 2);
+    }
+    catch {
+        return JSON.stringify({ scope, error: "Database not found" });
+    }
+}

package/dist/mcp-server.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env bun
+import * as path from "node:path";
+import * as os from "node:os";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createMemoryMcpServer } from "./mcp/server";
+import { mcpLog } from "./mcp/logging";
+const projectDir = process.env.MGMT_PROJECT_DIR || process.cwd();
+const globalDbPath = path.join(os.homedir(), ".config", "opencode", "memory.db");
+async function main() {
+    mcpLog("info", "MCP server starting", { name: "opencode-fractal-memory", version: "0.1.0" });
+    const server = await createMemoryMcpServer(projectDir, globalDbPath);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    mcpLog("info", "MCP server connected");
+}
+if (import.meta.main) {
+    main().catch(console.error);
+}

package/dist/memory.js

@@ -0,0 +1,2 @@
+export { createSqliteMemoryStore as createMemoryStore } from "./storage/sqlite";
+export { extractLinks, embeddingToBlob, blobToEmbedding, tokenize } from "./storage/utils";

package/dist/ollama.js

@@ -0,0 +1,74 @@
+// Ollama client for chat and reranking
+const OLLAMA_BASE = "http://localhost:11434";
+import { memLog } from "./logging";
+export async function chat(messages, opts = {}) {
+    const baseUrl = opts.baseUrl ?? OLLAMA_BASE;
+    const model = opts.model ?? "qwen2.5-coder:1.5b";
+    const res = await fetch(`${baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            model,
+            messages,
+            stream: false,
+            temperature: opts.temperature ?? 0.7,
+            seed: opts.seed,
+        }),
+    });
+    if (!res.ok) {
+        throw new Error(`Ollama error: ${res.status} ${res.statusText}`);
+    }
+    const data = await res.json();
+    return data.message?.content ?? "";
+}
+export async function rerankDocuments(query, candidates, opts = {}) {
+    const baseUrl = opts.baseUrl ?? OLLAMA_BASE;
+    const model = opts.model ?? "qwen2.5-coder:1.5b";
+    const topK = opts.topK ?? 5;
+    memLog("debug", "ollama", "[ollama] rerankDocuments called:", { model, baseUrl, candidateCount: candidates.length, topK });
+    const docsList = candidates.map((doc, i) => {
+        const content = doc.content.slice(0, 500);
+        return `${i + 1}. [${doc.label}]: ${content}`;
+    }).join("\n\n");
+    const prompt = `You are a relevance judge. Rate each document as 1 (relevant) or 0 (not relevant) for the query.
+
+IMPORTANT: You MUST return EXACTLY ${candidates.length} scores - one per document, in order.
+Example for 3 docs: [1, 0, 1]
+Your response must be ONLY a JSON array of ${candidates.length} numbers.
+
+Query: ${query}
+
+Documents:
+${docsList}
+
+Response (EXACTLY ${candidates.length} scores as JSON array):`;
+    try {
+        const response = await chat([{ role: "user", content: prompt }], { baseUrl, model, temperature: 0.0 });
+        const jsonMatch = response.match(/\[.*?\]/s);
+        if (!jsonMatch) {
+            memLog("error", "ollama", "[ollama] No JSON array found in response:", { response: response.slice(0, 200) });
+            return candidates.slice(0, topK).map(d => ({ id: d.id, score: 1 }));
+        }
+        const scores = JSON.parse(jsonMatch[0]);
+        if (!Array.isArray(scores) || scores.length === 0) {
+            memLog("error", "ollama", "[ollama] No valid scores in response:", { response: response.slice(0, 100) });
+            return candidates.slice(0, topK).map(d => ({ id: d.id, score: 1 }));
+        }
+        // Handle mismatch gracefully: pad with 1s or trim excess
+        const normalizedScores = [...scores];
+        while (normalizedScores.length < candidates.length) {
+            normalizedScores.push(1); // Pad with 1s (relevant)
+        }
+        const finalScores = normalizedScores.slice(0, candidates.length);
+        const results = candidates.map((d, i) => ({
+            id: d.id,
+            score: Number(finalScores[i]) === 1 ? 1 : 0,
+        }));
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, topK);
+    }
+    catch (err) {
+        memLog("error", "ollama", "Ollama rerank error:", { error: err instanceof Error ? err.message : err });
+        return candidates.slice(0, topK).map(d => ({ id: d.id, score: 1 }));
+    }
+}

package/dist/plugin/hooks.js

@@ -0,0 +1,168 @@
+import { memLog, memLogSimple, setSessionId } from "../logging";
+import { generateFileSummary, generateFileLabel, SOURCE_FILE_EXTENSIONS } from "../file-summary";
+import { distillRules, predictiveRateToolCall, applyScoreDecay } from "../hooks";
+import * as fs from "node:fs";
+export function createHookHandlers(store, client, memConfig, ruleCache, ruleCacheDirty, sessionInjectionLock, latestUserMessage) {
+    return {
+        "experimental.chat.system.transform": async (input, output) => {
+            const sessionId = input.sessionID ?? `session-${Date.now()}`;
+            setSessionId(sessionId);
+            if (sessionInjectionLock.get(sessionId))
+                return;
+            sessionInjectionLock.set(sessionId, true);
+            const reminders = [];
+            try {
+                if (ruleCacheDirty.value || ruleCache.size === 0) {
+                    const ruleLabels = [
+                        { label: "rule:mandatory:memory", type: "mandatory" },
+                        { label: "rule:mandatory:core", type: "mandatory" },
+                        { label: "rule:mandatory:agent-pull", type: "mandatory" },
+                        { label: "rule:mandatory:tools", type: "mandatory" },
+                        { label: "rule:standard", type: "standard" },
+                        { label: "rule:suggestion", type: "suggestion" },
+                    ];
+                    for (const { label, type } of ruleLabels) {
+                        let node = null;
+                        for (const scope of ["global", "project"]) {
+                            try {
+                                node = await store.getNodeByLabel(scope, label);
+                                break;
+                            }
+                            catch { /* ignore */ }
+                        }
+                        if (node) {
+                            let content = node.content || "";
+                            content = content.replace(/^## .*$/gm, "").replace(/^tag:.*$/gm, "").trim();
+                            if (content)
+                                ruleCache.set(label, { content, type });
+                        }
+                    }
+                    ruleCacheDirty.value = false;
+                }
+                for (const [label, cached] of ruleCache) {
+                    if (cached.type === "mandatory" || cached.type === "standard") {
+                        reminders.push(`<system_reminder type="${cached.type}">\n${cached.content}\n</system_reminder>`);
+                    }
+                }
+                if (reminders.length > 0) {
+                    const insertAt = output.system.length > 0 ? 1 : 0;
+                    output.system.splice(insertAt, 0, reminders.join("\n\n"));
+                }
+            }
+            catch (err) {
+                memLog("error", "injection", "Rule injection failed", { error: String(err) });
+            }
+            output.system = output.system.map((part) => part.replace(/<available_skills>[\s\S]*?<\/available_skills>/g, ""));
+            sessionInjectionLock.delete(sessionId);
+        },
+        "tool.execute.before": async (input, output) => {
+            const fileSummarization = memConfig?.autoFileSummarization;
+            if (!fileSummarization?.enabled)
+                return;
+            if (input.tool !== "read")
+                return;
+            const toolInput = input;
+            if (!toolInput.args?.filePath)
+                return;
+            const filePath = toolInput.args.filePath;
+            const fileExt = filePath.split('.').pop() ?? "";
+            if (!SOURCE_FILE_EXTENSIONS.includes(fileExt))
+                return;
+            try {
+                const shortLabel = generateFileLabel(filePath);
+                const nodes = await store.listNodes("project");
+                const cached = nodes.find(n => n.label === shortLabel);
+                if (cached) {
+                    output.output = cached.content;
+                    output.metadata = {
+                        ...(output.metadata ?? {}),
+                        cached: true,
+                    };
+                    memLogSimple(`FILE-CACHE-HIT: ${filePath} (${cached.content.length} chars)`, {
+                        label: shortLabel,
+                    });
+                }
+                else {
+                    memLogSimple(`FILE-CACHE-MISS: ${filePath}`, { label: shortLabel });
+                }
+            }
+            catch (err) {
+                memLog("warn", "file-summary", "Cache lookup failed", { error: String(err) });
+            }
+        },
+        "tool.execute.after": async (input, output) => {
+            if (input.tool?.startsWith("memory_")) {
+                await store.recordMemoryToolCall(input.sessionID ?? "unknown", input.tool, input.args);
+            }
+            const success = output.metadata?.error ? false : true;
+            if (memConfig?.predictiveRating?.enabled && input.tool?.startsWith("memory_")) {
+                predictiveRateToolCall(store, input, output, memConfig.predictiveRating).catch(err => memLog("warn", "predictive-rating", "Rating failed", { error: String(err) }));
+            }
+            if (!success)
+                return;
+            const fileSummarization = memConfig?.autoFileSummarization;
+            if (!fileSummarization?.enabled)
+                return;
+            if (input.tool !== "read")
+                return;
+            const toolInput = input;
+            if (!toolInput.args?.filePath)
+                return;
+            const isCached = output.metadata?.cached === true;
+            if (isCached)
+                return;
+            const filePath = toolInput.args.filePath;
+            const fileName = filePath.split('/').pop() ?? filePath;
+            const fileExt = fileName.split('.').pop() ?? "";
+            if (!SOURCE_FILE_EXTENSIONS.includes(fileExt))
+                return;
+            try {
+                const shortLabel = generateFileLabel(filePath);
+                const nodes = await store.listNodes("project");
+                const exists = nodes.some(n => n.label === shortLabel);
+                if (exists) {
+                    memLog("debug", "file-summary", "File memory already exists, skipping", { shortLabel });
+                    return;
+                }
+                let fullContent = "";
+                try {
+                    fullContent = fs.readFileSync(filePath, "utf-8");
+                }
+                catch (err) {
+                    memLog("warn", "file-summary", "Could not read full file, using tool output", { filePath, error: String(err) });
+                    fullContent = String(output.output ?? "");
+                }
+                const content = generateFileSummary(fileName, filePath, fullContent, fileExt);
+                await store.createNode({
+                    scope: "project",
+                    label: shortLabel,
+                    content,
+                    type: "note",
+                    level: 0,
+                    parentIds: null,
+                    embedding: null,
+                    importance: 0.7,
+                });
+                memLog("info", "file-summary", "Stored file memory", { label: shortLabel, fileName });
+            }
+            catch (err) {
+                memLog("warn", "file-summary", "Failed to store file memory", { error: String(err) });
+            }
+        },
+        "session.created": async (event) => {
+            const sessionId = event.properties?.info?.id ?? "unknown";
+            await store.createSessionMetrics(sessionId);
+            setSessionId(sessionId);
+        },
+        "session.idle": async (event) => {
+            const sessionId = event.properties?.sessionID ?? "unknown";
+            await store.updateSessionMetrics(sessionId, { endedAt: Date.now(), status: "completed" });
+            if (memConfig?.autoDistill?.enabled) {
+                distillRules(store, memConfig.autoDistill, sessionId, client).then(msg => memLog("info", "auto-distill", msg)).catch(err => memLog("error", "auto-distill", "Failed", { error: String(err) }));
+            }
+            if (memConfig?.predictiveRating?.enabled) {
+                applyScoreDecay(store, memConfig.predictiveRating).then(msg => memLog("info", "predictive-rating", msg)).catch(err => memLog("error", "predictive-rating", "Decay failed", { error: String(err) }));
+            }
+        },
+    };
+}

package/dist/plugin/index.js

@@ -0,0 +1,28 @@
+import { initStorage, loadPluginConfig, seedRuleNodes, backfillData, scheduleBackgroundEmbeddings, setupJournal, startManagementIfEnabled, createAutoRetrieveIfEnabled } from "./init";
+import { createHookHandlers } from "./hooks";
+import { createToolMap } from "./tools";
+export const MemoryPlugin = async (ctx) => {
+    const { directory, client } = ctx;
+    const store = await initStorage(directory);
+    const memConfig = await loadPluginConfig(directory);
+    await seedRuleNodes(store);
+    await backfillData(store);
+    scheduleBackgroundEmbeddings(store);
+    const journalTools = await setupJournal(directory);
+    startManagementIfEnabled(store, directory);
+    const ruleCache = new Map();
+    const ruleCacheDirty = { value: true };
+    const sessionInjectionLock = new Map();
+    const latestUserMessage = { value: "" };
+    const autoRetrieveHook = createAutoRetrieveIfEnabled(store, memConfig);
+    const handlers = createHookHandlers(store, client, memConfig, ruleCache, ruleCacheDirty, sessionInjectionLock, latestUserMessage);
+    const toolMap = createToolMap(store, journalTools, client);
+    return {
+        ...handlers,
+        ...(autoRetrieveHook || {}),
+        tool: toolMap,
+        cleanup: async () => {
+            await store.close();
+        },
+    };
+};