@lotargo/memory_plugin 1.4.5 → 1.4.601

package/mcp-server/config/config_manager.js

@@ -22,12 +22,9 @@ export const DEFAULT_CONFIG = {
 };
 
 let cachedConfig = null;
+let cachedMtimeMs = 0;
 
-export function getConfig() {
-  if (cachedConfig) {
-    return cachedConfig;
-  }
-
+function loadConfigFromDisk() {
   ensureDirSync();
 
   if (fs.existsSync(CONFIG_FILE)) {
@@ -35,6 +32,7 @@ export function getConfig() {
       const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
       const parsed = JSON.parse(raw);
       cachedConfig = Object.freeze({ ...DEFAULT_CONFIG, ...parsed });
+      cachedMtimeMs = fs.statSync(CONFIG_FILE).mtimeMs;
       return cachedConfig;
     } catch (err) {
       console.warn("Failed to read config file, falling back to defaults:", err.message);
@@ -46,11 +44,24 @@ export function getConfig() {
   return cachedConfig;
 }
 
+export function getConfig() {
+  try {
+    const mtimeMs = fs.statSync(CONFIG_FILE).mtimeMs;
+    if (cachedConfig && mtimeMs === cachedMtimeMs) {
+      return cachedConfig;
+    }
+  } catch (err) {
+    // Config file missing — fall through to load/create.
+  }
+  return loadConfigFromDisk();
+}
+
 export function saveConfig(newConfig) {
   ensureDirSync();
   cachedConfig = Object.freeze({ ...DEFAULT_CONFIG, ...newConfig });
   try {
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(cachedConfig, null, 2), "utf-8");
+    cachedMtimeMs = fs.statSync(CONFIG_FILE).mtimeMs;
   } catch (err) {
     console.error("Failed to write config file:", err.message);
   }

package/opencode-plugin/index.js

@@ -1,6 +1,6 @@
-const { readFile, writeFile, mkdir, cp, readdir, unlink } = await import("fs/promises");
+const { mkdir, cp, readdir } = await import("fs/promises");
 const { existsSync } = await import("fs");
-const { join, basename, dirname, resolve } = await import("path");
+const { join, dirname } = await import("path");
 const { homedir } = await import("os");
 const { fileURLToPath } = await import("url");
 const {
@@ -18,6 +18,20 @@ const {
   inDateRange,
 } = await import("../mcp-server/fact_format.js");
 
+const {
+  MEMORY_DIR,
+  GLOBAL_KEY,
+  canonicalPath,
+  projectName,
+  projectKey,
+  scopeKey,
+  readMemory,
+  writeMemory,
+  listProjectStores,
+  storeFilePath,
+  today,
+} = await import("../mcp-server/memory.js");
+
 // Resolve a fact reference (1-based number, metadata id, or text) to an index.
 function resolveFactIndex(entries, ref) {
   const trimmed = String(ref || "").trim();
@@ -31,9 +45,7 @@ function resolveFactIndex(entries, ref) {
 }
 
 const CONFIG_DIR = process.env.OPENCODE_CONFIG_DIR || join(homedir(), ".config", "opencode");
-const MEMORY_DIR = join(CONFIG_DIR, "memory");
 const SKILLS_DIR = join(CONFIG_DIR, "skills");
-const GLOBAL_KEY = "global";
 
 async function ensureDir() {
   if (!existsSync(MEMORY_DIR)) await mkdir(MEMORY_DIR, { recursive: true });
@@ -54,154 +66,6 @@ async function ensureDir() {
   } catch (e) {}
 }
 
-function canonicalPath(dir) {
-  let p = resolve(dir || process.cwd());
-  if (process.platform === "win32") {
-    p = p.replace(/\\/g, "/").replace(/^([a-zA-Z]):/, (_, d) => `${d.toLowerCase()}:`);
-  }
-  return p;
-}
-
-// Display label for a project (basename of the resolved directory).
-function projectName(worktree, directory) {
-  const dir = worktree || directory;
-  return dir ? basename(resolve(dir)) : "default";
-}
-
-// Project store key = full directory path (removes basename collisions).
-function projectKey(worktree, directory) {
-  return canonicalPath(worktree || directory);
-}
-
-function scopeKey(scope, worktree, directory) {
-  return scope === "global" ? GLOBAL_KEY : projectKey(worktree, directory);
-}
-
-function slugify(key) {
-  return key.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-
-function memoryPath(key) {
-  return join(MEMORY_DIR, `${slugify(key)}.md`);
-}
-
-function memoryFileName(key) {
-  return basename(memoryPath(key));
-}
-
-function parseMeta(content) {
-  const m = content.match(/<!-- path: (.+?) -->/);
-  return { path: m ? m[1].trim() : null };
-}
-
-function isSimpleKey(key) {
-  return /^[a-zA-Z0-9_-]+$/.test(key);
-}
-
-// Lazy migration: when reading a project path store that doesn't exist yet but a
-// legacy <basename>.md store (without path binding) does, claim it under the path.
-async function maybeMigrateLegacy(key) {
-  if (key === GLOBAL_KEY || isSimpleKey(key)) return null;
-  const legacyBasename = basename(key);
-  if (!legacyBasename) return null;
-  const legacyFp = join(MEMORY_DIR, `${legacyBasename}.md`);
-  if (slugify(key) === legacyBasename || !existsSync(legacyFp)) return null;
-  const content = await readFile(legacyFp, "utf-8");
-  if (parseMeta(content).path) return null; // already bound to another project
-  // Collision guard: a different path with the same basename is already bound,
-  // so this legacy store is ambiguous and must not be silently claimed.
-  const files = await readdir(MEMORY_DIR).catch(() => []);
-  for (const f of files) {
-    if (!f.endsWith(".md") || f === `${legacyBasename}.md` || f === `${GLOBAL_KEY}.md`) continue;
-    try {
-      const other = parseMeta(await readFile(join(MEMORY_DIR, f), "utf-8")).path;
-      if (other && basename(other) === legacyBasename) return null;
-    } catch (e) {}
-  }
-  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-  await writeMemory(key, facts);
-  try {
-    await unlink(legacyFp);
-  } catch (e) {}
-  return facts;
-}
-
-async function readMemory(key) {
-  const fp = memoryPath(key);
-  if (existsSync(fp)) {
-    const content = await readFile(fp, "utf-8");
-    return content.split("\n").filter((l) => l.startsWith("- ["));
-  }
-  const migrated = await maybeMigrateLegacy(key);
-  return migrated || [];
-}
-
-async function readMemoryRaw(key) {
-  return (await readMemory(key)).map((e) => e.slice(2));
-}
-
-async function writeMemory(key, entries) {
-  const lines = [];
-  if (key === GLOBAL_KEY) {
-    lines.push("# Global Memory", "");
-  } else {
-    lines.push(`# Memory: ${basename(key) || key}`, "");
-    if (!isSimpleKey(key)) {
-      lines.push(`<!-- path: ${key} -->`, "");
-    }
-  }
-  const content = lines.join("\n") + "\n" + (entries.length ? entries.join("\n") + "\n" : "");
-  await writeFile(memoryPath(key), content);
-}
-
-async function listProjectStores() {
-  const stores = [];
-  const files = await readdir(MEMORY_DIR).catch(() => []);
-  for (const f of files) {
-    if (!f.endsWith(".md") || f === `${GLOBAL_KEY}.md`) continue;
-    let content = "";
-    try {
-      content = await readFile(join(MEMORY_DIR, f), "utf-8");
-    } catch (e) {
-      continue;
-    }
-    const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-    const meta = parseMeta(content);
-    const key = meta.path || f.slice(0, -3);
-    stores.push({
-      key,
-      path: meta.path,
-      basename: basename(meta.path || key) || key,
-      file: f,
-      count: facts.length,
-      legacy: !meta.path,
-    });
-  }
-  stores.sort((a, b) => a.basename.localeCompare(b.basename));
-  return stores;
-}
-
-async function migrateLegacyStore(legacyKey, targetDir) {
-  const legacyFp = join(MEMORY_DIR, `${legacyKey.replace(/[^a-zA-Z0-9_-]/g, "_")}.md`);
-  if (!existsSync(legacyFp)) return { ok: false, reason: "not_found", key: legacyKey };
-  const content = await readFile(legacyFp, "utf-8");
-  if (parseMeta(content).path) return { ok: false, reason: "already_bound", key: legacyKey };
-  const targetKey = projectKey(targetDir, null);
-  const facts = content.split("\n").filter((l) => l.startsWith("- ["));
-  await writeMemory(targetKey, facts);
-  try {
-    await unlink(legacyFp);
-  } catch (e) {}
-  return { ok: true, key: targetKey, file: memoryPath(targetKey), facts: facts.length };
-}
-
-function today() {
-  const d = new Date();
-  const date = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
-  const time = `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
-  return `${date} ${time}`;
-}
-
 async function notify(client, message, variant = "success") {
   if (!client?.tui?.showToast) {
     await client?.app?.log({
@@ -459,7 +323,7 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
             if (results.length) results.push("");
             results.push(`--- ${key === GLOBAL_KEY ? "Global" : `Project: ${key === target ? label : key}`} ---`);
             matched.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, key)}`));
-            results.push(`Store file: ${memoryPath(key)}`);
+            results.push(`Store file: ${storeFilePath(key)}`);
           };
 
           if (scope === "list_projects") {
@@ -595,8 +459,8 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
             `Version: ${version}`,
             `MEMORY_DIR: ${MEMORY_DIR}`,
             `SQLite DB: ${dbPath}`,
-            `Global store: ${memoryPath(GLOBAL_KEY)}`,
-            `Project store: ${memoryPath(activeProjectKey)}`,
+            `Global store: ${storeFilePath(GLOBAL_KEY)}`,
+            `Project store: ${storeFilePath(activeProjectKey)}`,
           ];
           if (rag.error) lines.push(`RAG: unavailable (${rag.error})`);
           else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotargo/memory_plugin",
-  "version": "1.4.5",
+  "version": "1.4.601",
   "description": "100% local hybrid RAG memory for AI coding agents (OpenCode, Claude Code, Codex, Antigravity). MCP server + plugin: persistent user facts, document ingestion, vector + SQLite FTS5 retrieval across sessions.",
   "type": "module",
   "main": "opencode-plugin/index.js",