@lotargo/memory_plugin 1.1.7 → 1.1.9

package/mcp-server/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import readline from "readline";
 import { join } from "node:path";
 import { getConfig, updateConfig, resetConfig } from "./config/config_manager.js";
@@ -629,6 +629,24 @@ function waitForEnter() {
 }
 
 export async function runCli() {
+  const cliArgs = process.argv.slice(2);
+  if (cliArgs.includes("--enable-prompt") || cliArgs.includes("enable-prompt")) {
+    const { enableGlobalPrompt } = await import("./prompt_manager.js");
+    const results = await enableGlobalPrompt();
+    console.log("\n  [OK] Global prompt enabled across client configurations:\n");
+    results.forEach((r) => console.log(`  - ${r.name}: ${r.filePath} (${r.status})`));
+    console.log("");
+    return;
+  }
+  if (cliArgs.includes("--disable-prompt") || cliArgs.includes("disable-prompt")) {
+    const { disableGlobalPrompt } = await import("./prompt_manager.js");
+    const results = await disableGlobalPrompt();
+    console.log("\n  [OK] Global prompt disabled across client configurations:\n");
+    results.forEach((r) => console.log(`  - ${r.name}: ${r.filePath} (${r.status})`));
+    console.log("");
+    return;
+  }
+
   let running = true;
   let selectedIndex = 0;
 
@@ -731,6 +749,21 @@ export async function runCli() {
           },
         ],
       },
+      {
+        title: "Global Prompt & Integration Management",
+        items: [
+          {
+            label: "[PROMPT ENABLE] Enable Global Prompt (Antigravity / Codex / Claude)",
+            value: "enable_prompt",
+            info: "Inject memory instructions into ~/.gemini/config/AGENTS.md, ~/.codex/AGENTS.md, ~/.claude/CLAUDE.md",
+          },
+          {
+            label: "[PROMPT DISABLE] Disable Global Prompt",
+            value: "disable_prompt",
+            info: "Remove memory instructions from global AGENTS.md / CLAUDE.md files",
+          },
+        ],
+      },
       {
         title: "Diagnostics & System Actions",
         items: [
@@ -1590,6 +1623,24 @@ export async function runCli() {
         }
         break;
       }
+      case "enable_prompt": {
+        const { enableGlobalPrompt } = await import("./prompt_manager.js");
+        const results = await enableGlobalPrompt();
+        console.clear();
+        console.log("\n  [OK] Global prompt enabled across client configurations:\n");
+        results.forEach((r) => console.log(`  - ${r.name}: ${r.filePath} (${r.status})`));
+        await waitForEnter();
+        break;
+      }
+      case "disable_prompt": {
+        const { disableGlobalPrompt } = await import("./prompt_manager.js");
+        const results = await disableGlobalPrompt();
+        console.clear();
+        console.log("\n  [OK] Global prompt disabled across client configurations:\n");
+        results.forEach((r) => console.log(`  - ${r.name}: ${r.filePath} (${r.status})`));
+        await waitForEnter();
+        break;
+      }
       case "reset": {
         resetConfig();
         console.clear();

package/mcp-server/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import * as z from "zod/v4";

package/mcp-server/prompt_manager.js

@@ -0,0 +1,116 @@
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const START_MARKER = "<!-- START MEMORY AGENT PROMPT -->";
+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.
+${END_MARKER}`;
+
+export function getGlobalPromptTargets() {
+  const home = homedir();
+  return [
+    {
+      name: "Antigravity",
+      filePath: join(home, ".gemini", "config", "AGENTS.md"),
+    },
+    {
+      name: "Codex",
+      filePath: join(home, ".codex", "AGENTS.md"),
+    },
+    {
+      name: "Claude Code",
+      filePath: join(home, ".claude", "CLAUDE.md"),
+    },
+  ];
+}
+
+function stripPromptBlock(content) {
+  const startIndex = content.indexOf(START_MARKER);
+  const endIndex = content.indexOf(END_MARKER);
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const before = content.substring(0, startIndex);
+    const after = content.substring(endIndex + END_MARKER.length);
+    return (before + after).replace(/\n{3,}/g, "\n\n").trim();
+  }
+  return content.trim();
+}
+
+export async function enableGlobalPrompt() {
+  const targets = getGlobalPromptTargets();
+  const results = [];
+
+  for (const target of targets) {
+    try {
+      const parentDir = join(target.filePath, "..");
+      if (!existsSync(parentDir)) {
+        await mkdir(parentDir, { recursive: true });
+      }
+
+      let existing = "";
+      if (existsSync(target.filePath)) {
+        existing = await readFile(target.filePath, "utf-8");
+      }
+
+      const clean = stripPromptBlock(existing);
+      const updated = clean ? `${clean}\n\n${PROMPT_BLOCK}\n` : `${PROMPT_BLOCK}\n`;
+
+      await writeFile(target.filePath, updated, "utf-8");
+      results.push({ name: target.name, filePath: target.filePath, status: "enabled" });
+    } catch (err) {
+      results.push({ name: target.name, filePath: target.filePath, status: "failed", error: err.message });
+    }
+  }
+
+  return results;
+}
+
+export async function disableGlobalPrompt() {
+  const targets = getGlobalPromptTargets();
+  const results = [];
+
+  for (const target of targets) {
+    try {
+      if (!existsSync(target.filePath)) {
+        results.push({ name: target.name, filePath: target.filePath, status: "skipped" });
+        continue;
+      }
+
+      const existing = await readFile(target.filePath, "utf-8");
+      const clean = stripPromptBlock(existing);
+
+      if (clean.length === 0) {
+        await unlink(target.filePath);
+        results.push({ name: target.name, filePath: target.filePath, status: "removed_file" });
+      } else {
+        await writeFile(target.filePath, clean + "\n", "utf-8");
+        results.push({ name: target.name, filePath: target.filePath, status: "disabled" });
+      }
+    } catch (err) {
+      results.push({ name: target.name, filePath: target.filePath, status: "failed", error: err.message });
+    }
+  }
+
+  return results;
+}
+
+export async function getGlobalPromptStatus() {
+  const targets = getGlobalPromptTargets();
+  const status = [];
+
+  for (const target of targets) {
+    let enabled = false;
+    if (existsSync(target.filePath)) {
+      const content = await readFile(target.filePath, "utf-8");
+      enabled = content.includes(START_MARKER) && content.includes(END_MARKER);
+    }
+    status.push({ name: target.name, filePath: target.filePath, enabled });
+  }
+
+  return status;
+}

package/mcp-server/setup.js

@@ -32,12 +32,18 @@ export async function runSetup() {
         } catch (e) {}
       }
       if (!Array.isArray(config.plugin)) config.plugin = [];
-      // Clean up legacy / incorrect plugin entry names
-      const obsoleteNames = ["opencode-memory-plugin", "memory_plugin", "memory-plugin"];
-      config.plugin = config.plugin.filter((p) => !obsoleteNames.includes(p));
-      if (!config.plugin.includes("@lotargo/memory_plugin")) {
-        config.plugin.push("@lotargo/memory_plugin");
-      }
+      // Clean up legacy / obsolete / duplicate entries of OUR plugin only
+      const obsoleteNames = ["opencode-memory-plugin", "memory_plugin", "memory-plugin", "@lotargo/memory_plugin"];
+      config.plugin = config.plugin.filter((p) => {
+        if (typeof p !== "string") return true;
+        if (obsoleteNames.includes(p)) return false;
+        const normalized = p.replace(/\\/g, "/").toLowerCase();
+        if (normalized.endsWith("/memory") || normalized.endsWith("/memory_plugin") || normalized.endsWith("/memory-plugin")) {
+          return false;
+        }
+        return true;
+      });
+      config.plugin.push("@lotargo/memory_plugin");
       // Clean up legacy mcp-helper.js standalone file plugin if present
       const legacyPluginFile = join(opencodeDir, "plugins", "mcp-helper.js");
       if (existsSync(legacyPluginFile)) {
@@ -144,5 +150,19 @@ export async function runSetup() {
     }
   }
 
+  // 5. Global Prompt Instructions (Antigravity, Codex, Claude Code)
+  try {
+    const { enableGlobalPrompt } = await import("./prompt_manager.js");
+    const promptResults = await enableGlobalPrompt();
+    promptResults.forEach((r) => {
+      if (r.status === "enabled") {
+        console.log(`  [OK] ${r.name}: enabled global prompt instruction in ${r.filePath}`);
+      }
+    });
+  } catch (err) {
+    console.log("  [SKIP] Global prompt setup skipped:", err.message);
+  }
+
   console.log(`\nSetup complete. Configured ${configuredCount} environment(s).\n`);
 }
+

package/opencode-plugin/index.js

@@ -153,7 +153,12 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
         },
       },
       "remember": {
-        description: "Save an important, durable fact to memory. Only use for high-signal information (name, goals, constraints, tech preferences, project conventions). Translate the fact into English before saving. scope: 'project' (default) or 'global'",
+        description:
+          "Save an important, durable fact to memory. Only use for high-signal information " +
+          "(name, goals, constraints, tech preferences, project conventions). " +
+          "Optionally link the fact to a Knowledge Base document or exact line range (docId, startLine, endLine). " +
+          "Translate the fact into English and keep it concise. " +
+          "scope: 'project' (default) or 'global'",
         args: {
           fact: { type: "string", description: "The fact to remember, written in English" },
           scope: {
@@ -161,25 +166,52 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
             description: "'project' (default) or 'global'",
             default: "project",
           },
+          docId: { type: "string", description: "Optional document ID, title, or path to link this fact to" },
+          startLine: { type: "number", description: "Optional starting line number in target document" },
+          endLine: { type: "number", description: "Optional ending line number in target document" },
+          relationType: {
+            type: "string",
+            description: "Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'REFERENCES')",
+            default: "LINKS_TO",
+          },
         },
-        async execute({ fact, scope }, { worktree, directory }) {
+        async execute({ fact, scope, docId, startLine, endLine, relationType }, { worktree, directory }) {
           const key = scopeKey(scope || "project", worktree, directory);
           const entries = await readMemory(key);
           const factNormalized = fact.toLowerCase().trim();
-          if (entries.some((e) => {
+          if (!entries.some((e) => {
             const idx = e.indexOf("] ");
             return idx !== -1 && e.slice(idx + 2).toLowerCase().trim() === factNormalized;
           })) {
-            return "Already saved";
+            entries.push(`- [${today()}] ${fact}`);
+            await writeMemory(key, entries);
           }
-          entries.push(`- [${today()}] ${fact}`);
-          await writeMemory(key, entries);
-          await notify(client, "Memory updated");
-          return "Memory updated";
+
+          let linkInfo = "";
+          if (docId) {
+            try {
+              const { linkFactToDocument } = await import("../mcp-server/graph/knowledge_linker.js");
+              const linkRes = linkFactToDocument({
+                factKey: key,
+                factText: fact,
+                docId,
+                startLine,
+                endLine,
+                relationType: relationType || "LINKS_TO",
+              });
+              const linesStr = startLine ? `:L${startLine}${endLine ? `-${endLine}` : ""}` : "";
+              linkInfo = ` [Linked to Doc: "${linkRes.docTitle}"${linesStr}]`;
+            } catch (err) {
+              linkInfo = ` (Note: Fact saved, but document link failed: ${err.message})`;
+            }
+          }
+
+          await notify(client, "Memory updated" + linkInfo);
+          return "Memory updated" + linkInfo;
         },
       },
       "recall": {
-        description: "Показать запомненные факты (scope: project | global | all, по умолчанию все)",
+        description: "Show saved facts with any Agent-linked Knowledge Base documents/lines. scope: 'project', 'global', or 'all' (default)",
         args: {
           scope: {
             type: "string",
@@ -190,11 +222,37 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
         async execute({ scope }, { worktree, directory }) {
           const project = projectName(worktree, directory);
           const results = [];
+
+          let getLinksForFact;
+          try {
+            const linker = await import("../mcp-server/graph/knowledge_linker.js");
+            getLinksForFact = linker.getLinksForFact;
+          } catch (e) {}
+
+          const formatFactWithLinks = (factText, key) => {
+            let line = factText;
+            if (getLinksForFact) {
+              try {
+                const links = getLinksForFact(key, factText);
+                if (links && links.length > 0) {
+                  const docStr = links
+                    .map((l) => {
+                      const range = l.start_line ? `:L${l.start_line}${l.end_line ? `-${l.end_line}` : ""}` : "";
+                      return `${l.doc_title || l.doc_path}${range}`;
+                    })
+                    .join(", ");
+                  line += ` 🔗 [Linked Docs: ${docStr}]`;
+                }
+              } catch (e) {}
+            }
+            return line;
+          };
+
           if (scope !== "project") {
             const global = await readMemoryRaw(GLOBAL_KEY);
             if (global.length) {
               results.push("--- Global ---");
-              global.forEach((e, i) => results.push(`${i + 1}. ${e}`));
+              global.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, GLOBAL_KEY)}`));
             }
           }
           if (scope !== "global") {
@@ -202,7 +260,7 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
             if (local.length) {
               if (results.length) results.push("");
               results.push(`--- ${project} ---`);
-              local.forEach((e, i) => results.push(`${i + 1}. ${e}`));
+              local.forEach((e, i) => results.push(`${i + 1}. ${formatFactWithLinks(e, project)}`));
             }
           }
           return results.length ? results.join("\n") : "Memory is empty.";
@@ -237,6 +295,232 @@ export const MemoryPlugin = async ({ directory, worktree, client }) => {
           return result;
         },
       },
+      "link_knowledge": {
+        description:
+          "Explicitly link a Notebook memory fact to a Knowledge Base document, section, or line range. " +
+          "Creates Agent-driven Graph Edges connecting memory to RAG documents.",
+        args: {
+          action: {
+            type: "string",
+            description: "Action type: 'link' (default), 'list_links', 'get_doc_links'",
+            default: "link",
+          },
+          factText: { type: "string", description: "Memory fact text or keyword" },
+          docId: { type: "string", description: "Document ID, title, or file path" },
+          scope: { type: "string", description: "'project' (default) or 'global'", default: "project" },
+          startLine: { type: "number", description: "Starting line number in target document" },
+          endLine: { type: "number", description: "Ending line number in target document" },
+          relationType: {
+            type: "string",
+            description: "Relation type (e.g. 'RULES_FOR', 'IMPLEMENTS', 'EXPLAINS')",
+            default: "LINKS_TO",
+          },
+        },
+        async execute({ action, factText, docId, scope, startLine, endLine, relationType }, { worktree, directory }) {
+          const { linkFactToDocument, getLinksForDoc, listAllLinks } = await import("../mcp-server/graph/knowledge_linker.js");
+          const key = scopeKey(scope || "project", worktree, directory);
+          const act = action || "link";
+
+          if (act === "link") {
+            if (!factText || !docId) {
+              throw new Error("factText and docId are required parameters for link action");
+            }
+            const res = linkFactToDocument({
+              factKey: key,
+              factText,
+              docId,
+              startLine,
+              endLine,
+              relationType: relationType || "LINKS_TO",
+            });
+            return JSON.stringify(res, null, 2);
+          }
+
+          if (act === "get_doc_links") {
+            if (!docId) throw new Error("docId parameter is required for get_doc_links action");
+            const links = getLinksForDoc(docId);
+            return JSON.stringify(links, null, 2);
+          }
+
+          if (act === "list_links") {
+            const links = listAllLinks(key);
+            return JSON.stringify(links, null, 2);
+          }
+
+          throw new Error(`Unknown action: ${act}`);
+        },
+      },
+      "ingest_document": {
+        description:
+          "Ingest a document into the RAG knowledge base. " +
+          "Accepts local file paths, web URLs, or raw Markdown/text content. " +
+          "Processes document through 3-tier hierarchy chunking (Big/Medium/Small), " +
+          "computes dense vectors, and extracts GraphRAG code symbols.",
+        args: {
+          content: { type: "string", description: "Raw text content, file path, or web URL" },
+          type: { type: "string", description: "Input content type: 'text', 'file', 'url'", default: "text" },
+          title: { type: "string", description: "Document title" },
+          path: { type: "string", description: "Original document file path" },
+          generateEmbeddings: { type: "boolean", description: "Compute dense vector embeddings", default: true },
+        },
+        async execute({ content, type, title, path, generateEmbeddings }) {
+          const { ingestDocument } = await import("../mcp-server/ingest/pipeline.js");
+          const result = await ingestDocument({
+            content,
+            type: type || "text",
+            title: title || null,
+            path: path || null,
+            generateEmbeddings: generateEmbeddings !== false,
+          });
+          return JSON.stringify(
+            {
+              status: "success",
+              docId: result.docId,
+              title: result.title,
+              sectionsCount: result.sectionsCount,
+              microChunksCount: result.microChunksCount,
+              deduplicated: result.deduplicated,
+            },
+            null,
+            2
+          );
+        },
+      },
+      "query_knowledge_base": {
+        description:
+          "Perform hybrid search (RSF/RRF BM25 full-text + dense vector similarity) across the RAG knowledge base. " +
+          "Returns top-ranked candidate document sections with breadcrumbs, GraphRAG defined code symbols, and relevance scores.",
+        args: {
+          query: { type: "string", description: "Search query in natural language or symbol name" },
+          limit: { type: "number", description: "Maximum number of sections to return", default: 5 },
+          instruction: {
+            type: "string",
+            description: "Optional task-specific retrieval instruction shaping embedding focus",
+          },
+          generateEmbeddings: { type: "boolean", description: "Use vector search alongside BM25", default: true },
+        },
+        async execute({ query, limit, instruction, generateEmbeddings }) {
+          const { hybridQuery } = await import("../mcp-server/retrieval/retriever.js");
+          const { getConfig } = await import("../mcp-server/config/config_manager.js");
+          const activeConfig = getConfig();
+
+          const results = await hybridQuery({
+            query,
+            limit: limit || 5,
+            generateEmbeddings: generateEmbeddings !== false,
+            instruction: instruction || null,
+          });
+
+          if (!results || results.length === 0) {
+            return `[Active Model: ${activeConfig.embeddingModel}]\nNo matching knowledge found for query.`;
+          }
+
+          const headerNote = `[Active Model: ${activeConfig.embeddingModel} | Fusion: ${activeConfig.fusionAlgorithm.toUpperCase()}]\n\n`;
+
+          const formatted = results
+            .map((r, i) => {
+              let header = `### [${i + 1}] ${r.doc_title || "Untitled"}`;
+              if (r.heading) header += ` > ${r.heading}`;
+              if (r.breadcrumbs) header += ` (${r.breadcrumbs})`;
+              let body = `Score: ${(r.score || 0).toFixed(4)}\n`;
+              if (r.defined_symbols && r.defined_symbols.length > 0) {
+                body += `Defined Symbols: ${r.defined_symbols.join(", ")}\n`;
+              }
+              body += `\n${r.snippet || r.full_section_content || ""}`;
+              return `${header}\n${body}`;
+            })
+            .join("\n\n---\n\n");
+
+          return headerNote + formatted;
+        },
+      },
+      "manage_knowledge_base": {
+        description:
+          "Manage the RAG knowledge base: inspect stats, list documents, read full raw document, delete documents, or export/import snapshots.",
+        args: {
+          action: {
+            type: "string",
+            description: "Management action: 'stats', 'list', 'read_document', 'delete', 'export_snapshot', 'import_snapshot'",
+          },
+          docId: { type: "string", description: "Document ID, title, or path (required for read_document and delete)" },
+          snapshotPath: { type: "string", description: "File path for snapshot export/import" },
+        },
+        async execute({ action, docId, snapshotPath }) {
+          const { getDatabase } = await import("../mcp-server/db/database.js");
+          const db = getDatabase();
+
+          if (action === "stats") {
+            const docCount = db.prepare("SELECT COUNT(*) as cnt FROM documents").get().cnt;
+            const secCount = db.prepare("SELECT COUNT(*) as cnt FROM sections").get().cnt;
+            const chunkCount = db.prepare("SELECT COUNT(*) as cnt FROM micro_chunks").get().cnt;
+            const edgeCount = db.prepare("SELECT COUNT(*) as cnt FROM graph_edges").get().cnt;
+            return JSON.stringify(
+              {
+                documents: docCount,
+                sections: secCount,
+                micro_chunks: chunkCount,
+                graph_edges: edgeCount,
+              },
+              null,
+              2
+            );
+          }
+
+          if (action === "list") {
+            const docs = db
+              .prepare("SELECT id, title, path, blob_hash, created_at FROM documents ORDER BY created_at DESC")
+              .all();
+            return JSON.stringify(docs, null, 2);
+          }
+
+          if (action === "read_document") {
+            if (!docId) throw new Error("docId parameter is required for read_document action");
+            const doc = db
+              .prepare("SELECT id, title, path, blob_hash, created_at FROM documents WHERE id = ? OR path = ? OR title = ?")
+              .get(docId, docId, docId);
+            if (!doc) {
+              throw new Error(`Document not found in knowledge base for docId: ${docId}`);
+            }
+            const { readBlob } = await import("../mcp-server/storage/blob_store.js");
+            const rawContent = await readBlob(doc.blob_hash);
+            return JSON.stringify(
+              {
+                id: doc.id,
+                title: doc.title,
+                path: doc.path,
+                created_at: doc.created_at,
+                content: rawContent,
+              },
+              null,
+              2
+            );
+          }
+
+          if (action === "delete") {
+            if (!docId) throw new Error("docId parameter is required for delete action");
+            const { deleteDocument } = await import("../mcp-server/ingest/pipeline.js");
+            const result = await deleteDocument(docId, db);
+            return JSON.stringify(result, null, 2);
+          }
+
+          if (action === "export_snapshot") {
+            const { exportSnapshot } = await import("../mcp-server/admin/snapshot.js");
+            const result = await exportSnapshot({ customDb: db, outputPath: snapshotPath || null });
+            return snapshotPath
+              ? `Snapshot exported successfully to ${snapshotPath}`
+              : JSON.stringify(result, null, 2);
+          }
+
+          if (action === "import_snapshot") {
+            if (!snapshotPath) throw new Error("snapshotPath parameter is required for import_snapshot action");
+            const { importSnapshot } = await import("../mcp-server/admin/snapshot.js");
+            const result = await importSnapshot({ customDb: db, snapshotPathOrData: snapshotPath });
+            return JSON.stringify(result, null, 2);
+          }
+
+          throw new Error(`Unknown action: ${action}`);
+        },
+      },
     },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotargo/memory_plugin",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "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",
@@ -28,6 +28,7 @@
     "mcp-server/memory.js",
     "mcp-server/setup.js",
     "mcp-server/preinstall.js",
+    "mcp-server/prompt_manager.js",
     "skills"
   ],
   "keywords": [