opencode-fractal-memory 0.3.0 → 0.4.1

package/dist/mcp/server.js

@@ -3,10 +3,18 @@ import { z } from "zod";
 import { createSqliteMemoryStore } from "../storage/sqlite";
 import { withMcpLogging, mcpLog } from "./logging";
 import { nodeToPlain, ensureScope, resourceStats } from "./transform";
+import { fileURLToPath } from "node:url";
+import * as path from "node:path";
+import * as fs from "node:fs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../package.json"), "utf-8"));
 let store;
 export async function createMemoryMcpServer(projectDir, globalDbPath) {
+    mcpLog("info", "Creating memory store", { projectDir });
     store = createSqliteMemoryStore(projectDir, globalDbPath);
-    const server = new McpServer({ name: "opencode-fractal-memory", version: "0.1.0" }, { capabilities: { tools: {}, resources: {} } });
+    mcpLog("info", "Memory store created");
+    const server = new McpServer({ name: "opencode-fractal-memory", version: pkg.version }, { capabilities: { tools: {}, resources: {} } });
     server.registerTool("memory_search", {
         description: "Search memory nodes by text, embedding similarity, or BM25 score",
         inputSchema: {

package/dist/mcp-server.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env bun
 import * as path from "node:path";
 import * as os from "node:os";
+import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { createMemoryMcpServer } from "./mcp/server";
 import { mcpLog } from "./mcp/logging";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../package.json"), "utf-8"));
 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" });
+    mcpLog("info", "MCP server starting", { name: "opencode-fractal-memory", version: pkg.version });
     const server = await createMemoryMcpServer(projectDir, globalDbPath);
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/plugin/index.js

@@ -1,15 +1,32 @@
 import { initStorage, loadPluginConfig, seedRuleNodes, backfillData, scheduleBackgroundEmbeddings, setupJournal, startManagementIfEnabled, createAutoRetrieveIfEnabled } from "./init";
 import { createHookHandlers } from "./hooks";
 import { createToolMap } from "./tools";
+import { memLog, perfNow } from "../logging";
 export const MemoryPlugin = async (ctx) => {
     const { directory, client } = ctx;
+    const t0 = perfNow();
+    memLog("info", "init", "Plugin initialization started", { directory });
+    let t = perfNow();
     const store = await initStorage(directory);
+    memLog("info", "init", "Storage initialized", { durationMs: perfNow() - t });
+    t = perfNow();
     const memConfig = await loadPluginConfig(directory);
+    memLog("info", "init", "Config loaded", { durationMs: perfNow() - t });
+    t = perfNow();
     await seedRuleNodes(store);
+    memLog("info", "init", "Seed nodes completed", { durationMs: perfNow() - t });
+    t = perfNow();
     await backfillData(store);
+    memLog("info", "init", "Backfill completed", { durationMs: perfNow() - t });
+    t = perfNow();
     scheduleBackgroundEmbeddings(store);
+    memLog("info", "init", "Background embeddings scheduled", { durationMs: perfNow() - t });
+    t = perfNow();
     const journalTools = await setupJournal(directory);
+    memLog("info", "init", "Journal setup completed", { durationMs: perfNow() - t });
+    t = perfNow();
     startManagementIfEnabled(store, directory);
+    memLog("info", "init", "Management server check completed", { durationMs: perfNow() - t });
     const ruleCache = new Map();
     const ruleCacheDirty = { value: true };
     const sessionInjectionLock = new Map();
@@ -17,6 +34,7 @@ export const MemoryPlugin = async (ctx) => {
     const autoRetrieveHook = createAutoRetrieveIfEnabled(store, memConfig);
     const handlers = createHookHandlers(store, client, memConfig, ruleCache, ruleCacheDirty, sessionInjectionLock, latestUserMessage);
     const toolMap = createToolMap(store, journalTools, client);
+    memLog("info", "init", "Plugin initialization completed", { totalDurationMs: perfNow() - t0 });
     return {
         ...handlers,
         ...(autoRetrieveHook || {}),

package/dist/plugin/init.js

@@ -12,10 +12,15 @@ import { memLog } from "../logging";
 import { setCacheConfig } from "../cache";
 import { setHighContextThreshold, setCriticalContextThreshold, setMaxInjectionTokens, setCoreInjectionTokens, setAutoCompressThreshold } from "./state";
 export async function initStorage(directory) {
+    memLog("info", "init", "Creating memory store", { directory });
     const store = createMemoryStore(directory);
+    memLog("info", "init", "Ensuring seed nodes");
     await store.ensureSeed();
+    memLog("info", "init", "Ensuring models");
     await ensureModels();
+    memLog("info", "init", "Ensuring agent files");
     await ensureAgentFiles().catch(() => { });
+    memLog("info", "init", "Ensuring command files");
     await ensureCommandFiles().catch(() => { });
     return store;
 }
@@ -31,6 +36,7 @@ export async function loadPluginConfig(directory) {
     return memConfig;
 }
 export async function seedRuleNodes(store) {
+    let created = 0;
     for (const seed of SEED_NODES) {
         try {
             await store.getNodeByLabel("global", seed.label);
@@ -48,15 +54,21 @@ export async function seedRuleNodes(store) {
                 importance: 1,
                 metadata: seed.metadata ?? null,
             });
+            created++;
         }
     }
+    memLog("info", "init", "Seed nodes checked", { total: SEED_NODES.length, created });
 }
 export async function backfillData(store) {
     for (const scope of ["global", "project"]) {
+        memLog("info", "init", `Backfilling links for ${scope}`);
         await store.backfillLinks(scope);
+        memLog("info", "init", `Backfilling embeddings and BM25 for ${scope}`);
         await store.backfillBinaryEmbeddingsAndBM25(scope);
     }
+    memLog("info", "init", "Rebuilding HNSW index");
     await store.rebuildHNSWIndex();
+    memLog("info", "init", "HNSW index rebuilt");
 }
 export function scheduleBackgroundEmbeddings(store) {
     setTimeout(async () => {
@@ -94,9 +106,13 @@ export function startManagementIfEnabled(store, directory) {
     loadConfig().then(c => {
         const mgmtConfig = c.management;
         if (mgmtConfig?.enabled === true) {
+            memLog("info", "init", "Starting management server", { port: mgmtConfig.port ?? 8787 });
             startManagementServer(store, directory, { enabled: true, port: mgmtConfig?.port ?? 8787 });
         }
-    }).catch(() => { });
+        else {
+            memLog("info", "init", "Management server disabled");
+        }
+    }).catch(() => { memLog("info", "init", "Management server config not available"); });
 }
 export function createAutoRetrieveIfEnabled(store, memConfig) {
     return memConfig?.autoRetrieve?.enabled

package/dist/tools/version.js

@@ -1,6 +1,12 @@
 import { tool } from "@opencode-ai/plugin";
 import { wrapWithTracking } from "./shared";
-const VERSION = "0.2.0";
+import { fileURLToPath } from "node:url";
+import * as path from "node:path";
+import * as fs from "node:fs";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../package.json"), "utf-8"));
+const VERSION = pkg.version;
 export function MemoryVersion(store) {
     const t = tool({
         description: "Show the installed version of the Fractal Memory plugin.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-fractal-memory",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Fractal memory system for OpenCode with semantic search and automatic compression.",
   "main": "dist/plugin.js",
   "type": "module",