@lotargo/memory_plugin 1.2.0 → 1.2.2

package/mcp-server/cli.js

@@ -1109,13 +1109,26 @@ export async function runCli() {
             break;
           }
 
-          const docItems = docs.map((doc) => ({
-            label: doc.title || doc.path || "Untitled Document",
-            badge: doc.created_at ? doc.created_at.substring(0, 16) : "",
-            hint: doc.id ? `ID: ${doc.id.substring(0, 8)}...` : "",
-            info: `Path: ${doc.path || "N/A"}`,
-            value: doc,
-          }));
+          const docItems = docs.map((doc) => {
+            const rawDate = doc.created_at || doc.updated_at || "";
+            let formattedDate = "";
+            if (rawDate) {
+              try {
+                const d = typeof rawDate === "number" ? new Date(rawDate) : new Date(String(rawDate));
+                formattedDate = isNaN(d.getTime()) ? String(rawDate).substring(0, 16) : d.toISOString().replace("T", " ").substring(0, 16);
+              } catch (e) {
+                formattedDate = String(rawDate).substring(0, 16);
+              }
+            }
+            const docIdStr = doc.id != null ? String(doc.id) : "";
+            return {
+              label: doc.title || doc.path || "Untitled Document",
+              badge: formattedDate,
+              hint: docIdStr ? `ID: ${docIdStr.substring(0, 8)}...` : "",
+              info: `Path: ${doc.path || "N/A"}`,
+              value: doc,
+            };
+          });
           docItems.push({ label: "< Back to Main Menu", value: "back" });
 
           const docRes = await selectSimpleMenu({

package/mcp-server/ml/model_manager.js

@@ -23,6 +23,25 @@ function getOptimalThreadCount() {
   return Math.max(1, Math.min(totalCores, 8));
 }
 
+export function ensureValidModelDirectory() {
+  try {
+    if (!fs.existsSync(MODELS_DIR)) {
+      fs.mkdirSync(MODELS_DIR, { recursive: true });
+    }
+    const testFile = path.join(MODELS_DIR, ".path_check");
+    fs.writeFileSync(testFile, "ok");
+    fs.unlinkSync(testFile);
+    return MODELS_DIR;
+  } catch (err) {
+    console.warn(`[Self-Healing] Model directory path "${MODELS_DIR}" is inaccessible or invalid (${err.message}). Falling back to standard default model storage path...`);
+    const fallbackDir = path.join(MODELS_DIR, "..", "models");
+    try {
+      fs.mkdirSync(fallbackDir, { recursive: true });
+    } catch (e) {}
+    return fallbackDir;
+  }
+}
+
 export async function getExtractor(modelName = null, progressCallback = null) {
   const targetModel = modelName || getConfig().embeddingModel || "Xenova/multilingual-e5-small";
 
@@ -43,9 +62,12 @@ export async function getExtractor(modelName = null, progressCallback = null) {
     return extractorInstance;
   }
 
+  // Ensure valid writable storage directory
+  const cacheDir = ensureValidModelDirectory();
+
   const { pipeline, env } = await import("@huggingface/transformers");
 
-  env.cacheDir = MODELS_DIR;
+  env.cacheDir = cacheDir;
   env.allowLocalModels = true;
   env.allowRemoteModels = true;
   env.remoteHost = "https://huggingface.co";
@@ -93,18 +115,56 @@ export async function getExtractor(modelName = null, progressCallback = null) {
       } catch {}
     }
   } catch (err) {
+    const isNetworkError = err.message && (
+      err.message.includes("fetch") ||
+      err.message.includes("network") ||
+      err.message.includes("ETIMEDOUT") ||
+      err.message.includes("ENOTFOUND") ||
+      err.message.includes("503") ||
+      err.message.includes("502") ||
+      err.message.includes("504")
+    );
+
+    if (isNetworkError) {
+      console.warn(`[Model Manager] ⚠️ Network interruption while loading "${targetModel}": ${err.message}. Retrying / Resuming download...`);
+    } else {
+      console.warn(`[Model Manager] ⚠️ Unrecoverable file error for "${targetModel}": ${err.message}. Purging corrupted cache...`);
+      deleteModelCache(targetModel);
+    }
+
     if (targetDevice !== "cpu") {
-      console.warn(`[GPU Engine] GPU initialization (${targetDevice}) failed: ${err.message}. Falling back to CPU...`);
+      console.warn(`[GPU Engine] GPU initialization (${targetDevice}) failed. Retrying on CPU...`);
       pipelineOpts.device = "cpu";
       pipelineOpts.session_options.executionMode = "sequential";
-      extractorInstance = await pipeline("feature-extraction", targetModel, pipelineOpts);
-      loadedModelName = targetModel;
-      loadedDevice = "cpu";
-    } else if (targetModel !== "Xenova/multilingual-e5-small") {
-      console.warn(`HuggingFace model load failed for ${targetModel}: ${err.message}. Falling back to default Xenova/multilingual-e5-small...`);
-      extractorInstance = await pipeline("feature-extraction", "Xenova/multilingual-e5-small", pipelineOpts);
-      loadedModelName = "Xenova/multilingual-e5-small";
-      loadedDevice = targetDevice;
+      try {
+        extractorInstance = await pipeline("feature-extraction", targetModel, pipelineOpts);
+        loadedModelName = targetModel;
+        loadedDevice = "cpu";
+        return extractorInstance;
+      } catch (err2) {
+        if (!isNetworkError) deleteModelCache(targetModel);
+      }
+    }
+
+    if (targetModel !== "Xenova/multilingual-e5-small") {
+      console.warn(`[Fallback] Reverting to standard default model "Xenova/multilingual-e5-small"...`);
+      resetExtractor();
+      try {
+        const fallbackOpts = {
+          quantized: true,
+          dtype: "q8",
+          device: "cpu",
+          session_options: { graphOptimizationLevel: "all", executionMode: "sequential" },
+        };
+        if (progressCallback) fallbackOpts.progress_callback = progressCallback;
+
+        extractorInstance = await pipeline("feature-extraction", "Xenova/multilingual-e5-small", fallbackOpts);
+        loadedModelName = "Xenova/multilingual-e5-small";
+        loadedDevice = "cpu";
+      } catch (err3) {
+        console.error(`[Fatal] Could not load default fallback model: ${err3.message}`);
+        throw err3;
+      }
     } else {
       throw err;
     }
@@ -119,6 +179,38 @@ export function resetExtractor() {
   loadedDevice = null;
 }
 
+export function deleteModelCache(modelName) {
+  const info = getModelStorageInfo(modelName);
+  if (info.status === "not_downloaded" || !fs.existsSync(info.dir)) {
+    return { deleted: false, reason: "Model directory not found" };
+  }
+
+  resetExtractor();
+  if (global.gc) {
+    try { global.gc(); } catch (e) {}
+  }
+
+  try {
+    fs.rmSync(info.dir, { recursive: true, force: true });
+    const parentDir = path.dirname(info.dir);
+    if (fs.existsSync(parentDir) && fs.readdirSync(parentDir).length === 0) {
+      fs.rmdirSync(parentDir);
+    }
+    return { deleted: true, modelName, freedMB: info.sizeMB };
+  } catch (err) {
+    try {
+      const corruptPath = `${info.dir}.corrupt_${Date.now()}`;
+      fs.renameSync(info.dir, corruptPath);
+      setTimeout(() => {
+        try { fs.rmSync(corruptPath, { recursive: true, force: true }); } catch (e) {}
+      }, 1000);
+      return { deleted: true, modelName, freedMB: info.sizeMB };
+    } catch (renameErr) {
+      return { deleted: false, reason: `${err.message} (Rename fallback: ${renameErr.message})` };
+    }
+  }
+}
+
 export function formatInputText(text, isQuery = false, modelName = null, instruction = null) {
   if (!text) return "";
   const targetModel = modelName || getConfig().embeddingModel || "Xenova/multilingual-e5-small";
@@ -296,6 +388,8 @@ export async function getReranker(modelName = "Xenova/bge-reranker-base", progre
     return rerankerInstance;
   }
 
+  checkAndSelfHealModel(modelName);
+
   const { pipeline, env } = await import("@huggingface/transformers");
   env.cacheDir = MODELS_DIR;
   env.allowLocalModels = true;
@@ -338,7 +432,8 @@ export async function getReranker(modelName = "Xenova/bge-reranker-base", progre
     rerankerInstance = await pipeline("text-classification", modelName, pipelineOpts);
     loadedRerankerName = modelName;
   } catch (err) {
-    console.warn(`Failed to load reranker model ${modelName}: ${err.message}`);
+    console.warn(`Failed to load reranker model ${modelName}: ${err.message}. Purging corrupt files...`);
+    deleteModelCache(modelName);
     return null;
   }
   return rerankerInstance;
@@ -451,25 +546,6 @@ export function getModelStorageInfo(modelName) {
   return { status: "partial", sizeMB, bytes: totalBytes, dir: modelDir };
 }
 
-export function deleteModelCache(modelName) {
-  const info = getModelStorageInfo(modelName);
-  if (info.status === "not_downloaded" || !fs.existsSync(info.dir)) {
-    return { deleted: false, reason: "Model directory not found" };
-  }
-
-  try {
-    fs.rmSync(info.dir, { recursive: true, force: true });
-    const parentDir = path.dirname(info.dir);
-    if (fs.existsSync(parentDir) && fs.readdirSync(parentDir).length === 0) {
-      fs.rmdirSync(parentDir);
-    }
-    resetExtractor();
-    return { deleted: true, modelName, freedMB: info.sizeMB };
-  } catch (err) {
-    return { deleted: false, reason: err.message };
-  }
-}
-
 export function listAllCachedModels() {
   const result = [];
   if (!fs.existsSync(MODELS_DIR)) return result;

package/mcp-server/prompt_manager.js

@@ -8,7 +8,9 @@ const END_MARKER = "<!-- END MEMORY AGENT PROMPT -->";
 
 export const PROMPT_BLOCK = `${START_MARKER}
 [SYSTEM INSTRUCTION: PERSONAL CONTEXT & MEMORY AGENT]
-When starting a session or when personal/project context is relevant, use \`recall\` from \`memory-agent\` to load saved facts, user preferences, and project guidelines. Use \`remember\` to save any durable high-signal facts provided by the user.
+1. MANDATORY FIRST STEP (SESSION INITIALIZATION): At the very start of every session or conversation, your VERY FIRST ACTION MUST BE to execute \`recall\` from \`memory-agent\` to load all saved facts, user preferences, personal context, and project guidelines BEFORE performing any other tasks or reading code.
+2. PROACTIVE SAVING DIRECTIVE: You MUST automatically and proactively call \`remember\` from \`memory-agent\` whenever the user shares durable facts, personal preferences, coding guidelines, technology choices, or project architecture decisions. Do NOT wait for explicit user commands like "remember this".
+3. SIGNAL FILTER: Save only high-signal facts (name, language, roles, constraints, tech stack preferences, architecture decisions, conventions). Translate facts into clear, concise English when saving. Do NOT save transient details or one-off conversation turns.
 ${END_MARKER}`;
 
 export function getGlobalPromptTargets() {

package/opencode-plugin/index.js

@@ -74,12 +74,15 @@ async function notify(client, message, variant = "success") {
 }
 
 const MEMORY_INSTRUCTION =
+  "MANDATORY FIRST STEP (READ MEMORIES FIRST):\n" +
+  "At the start of every session, you MUST thoroughly review all saved memories provided below BEFORE performing any user task or editing code.\n" +
+  "PROACTIVE MEMORY DIRECTIVE:\n" +
+  "You MUST automatically and proactively call `remember` whenever the user shares durable facts, personal preferences, coding guidelines, tech stack choices, architecture decisions, or project conventions.\n" +
+  "Do NOT wait for explicit user commands like \"remember this\". Automatically capture high-signal facts in real time.\n" +
   "Use `remember` only for important, durable facts about the user and project.\n" +
-  "Save high-signal things like: name, language, role/goals, constraints, tech\n" +
-  "stack preferences, architecture decisions, project conventions.\n" +
-  "DO NOT save: transient details, one-off statements, full conversation turns,\n" +
-  "or anything unlikely to be useful in future sessions.\n" +
-  "When saving, translate the fact into English and keep it concise.\n" +
+  "Save high-signal items: user role, goals, constraints, tech stack preferences, architecture decisions, project conventions.\n" +
+  "DO NOT save: transient details, one-off statements, full conversation turns, or anything unlikely to be useful in future sessions.\n" +
+  "When saving, translate the fact into clear, concise English.\n" +
   "Use `scope: \"global\"` for personal facts, `scope: \"project\"` for project-specific facts.";
 
 function buildMemoryContext(globalFacts, projectFacts, projectKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotargo/memory_plugin",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Persistent memory agent for coding AI tools — remembers user preferences and project context across sessions. Works with Antigravity, OpenCode, Claude Code, and Codex.",
   "type": "module",
   "main": "opencode-plugin/index.js",

package/skills/using-memory/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: using-memory
-description: Comprehensive guide for using the Memory & Hybrid RAG Knowledge Engine tools (remember, recall, forget, ingest_document, query_knowledge_base, manage_knowledge_base). Trigger whenever remembering user preferences/conventions, querying ingested documentation, indexing files/repos, or managing persistent knowledge.
+description: Comprehensive guide for using the Memory & Hybrid RAG Knowledge Engine tools (remember, recall, forget, link_knowledge, ingest_document, query_knowledge_base, manage_knowledge_base). Trigger proactively whenever user preferences, project conventions, technology stack choices, or architecture decisions are introduced, or when querying ingested documentation, indexing files/repos, or managing persistent knowledge.
 ---
 
 # Using Memory & Hybrid RAG Knowledge Engine
@@ -116,7 +116,8 @@ In such cases, use the **Full Raw Document Reading** mechanism:
 
 ## 4. Core Directives for AI Agents
 
-1. **Be Proactive**: When the user mentions a durable preference or constraint, save it immediately using `remember`.
-2. **Check Knowledge Base First**: If a user asks how a specific module, API, or project architecture works, call `query_knowledge_base` using concept-dense search phrases.
-3. **Inspect Ambiguous Docs Directly**: If querying produces low relevance scores on abstractly-named documents, call `manage_knowledge_base(action: "read_document")` to inspect the full text directly.
-4. **Keep Memory Clean**: If a preference changes, call `forget` on the outdated entry before saving the new one.
+1. **Read Memories First (MANDATORY)**: At the very start of any session or conversation, your VERY FIRST STEP MUST BE to execute `recall` to load all saved facts, user context, and project guidelines BEFORE performing any other task or code analysis.
+2. **Be Proactive**: When the user mentions a durable preference, personal fact, or constraint, save it immediately using `remember`. Do not wait for explicit user commands.
+3. **Check Knowledge Base First**: If a user asks how a specific module, API, or project architecture works, call `query_knowledge_base` using concept-dense search phrases.
+4. **Inspect Ambiguous Docs Directly**: If querying produces low relevance scores on abstractly-named documents, call `manage_knowledge_base(action: "read_document")` to inspect the full text directly.
+5. **Keep Memory Clean**: If a preference changes, call `forget` on the outdated entry before saving the new one.