mr-memory 2.22.2 → 3.0.1

package/index.ts

@@ -8,8 +8,9 @@
  * BYOK — provider API keys never touch MemoryRouter.
  */
 
-import { readFile, readdir, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { readFile, readdir, stat, lstat } from "node:fs/promises";
+import { join, resolve, relative, isAbsolute, sep } from "node:path";
+import path from "node:path";
 import { spawn } from "node:child_process";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 
@@ -48,6 +49,97 @@ function stripOldMemory(text: string): string {
   return text.replace(MEMORY_TAG_RE, "").replace(LEGACY_TAG_RE, "").trim();
 }
 
+// ── Tool result helper (matches OpenClaw's jsonResult format)
+function jsonToolResult(payload: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(payload, null, 2) }], details: payload };
+}
+
+// ── memory_get helpers (copied from OpenClaw source — pure filesystem, no embeddings)
+function isFileMissingError(err: unknown): boolean {
+  return Boolean(err && typeof err === "object" && "code" in err && (err as any).code === "ENOENT");
+}
+
+async function statRegularFile(absPath: string): Promise<{ missing: boolean; stat?: any }> {
+  let s;
+  try {
+    s = await lstat(absPath);
+  } catch (err) {
+    if (isFileMissingError(err)) return { missing: true };
+    throw err;
+  }
+  if (s.isSymbolicLink() || !s.isFile()) throw new Error("path required");
+  return { missing: false, stat: s };
+}
+
+function normalizeRelPath(value: string): string {
+  return value.trim().replace(/^[./]+/, "").replace(/\\/g, "/");
+}
+
+function normalizeExtraMemoryPaths(workspaceDir: string, extraPaths?: string[]): string[] {
+  if (!extraPaths?.length) return [];
+  const resolved = extraPaths
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .map((value) => isAbsolute(value) ? resolve(value) : resolve(workspaceDir, value));
+  return Array.from(new Set(resolved));
+}
+
+function isMemoryPath(relPath: string): boolean {
+  const normalized = normalizeRelPath(relPath);
+  if (!normalized) return false;
+  if (normalized === "MEMORY.md" || normalized === "memory.md") return true;
+  return normalized.startsWith("memory/");
+}
+
+/** Exact copy of OpenClaw's manager.readFile — pure local file read with security gate */
+async function memoryGetReadFile(
+  workspaceDir: string,
+  params: { relPath: string; from?: number; lines?: number },
+  extraPaths?: string[],
+): Promise<{ text: string; path: string }> {
+  const rawPath = params.relPath.trim();
+  if (!rawPath) throw new Error("path required");
+  const absPath = isAbsolute(rawPath) ? resolve(rawPath) : resolve(workspaceDir, rawPath);
+  const relPath = relative(workspaceDir, absPath).replace(/\\/g, "/");
+  const allowedWorkspace = relPath.length > 0 && !relPath.startsWith("..") && !isAbsolute(relPath) && isMemoryPath(relPath);
+  let allowedAdditional = false;
+  if (!allowedWorkspace && extraPaths && extraPaths.length > 0) {
+    const additionalPaths = normalizeExtraMemoryPaths(workspaceDir, extraPaths);
+    for (const additionalPath of additionalPaths) try {
+      const s = await lstat(additionalPath);
+      if (s.isSymbolicLink()) continue;
+      if (s.isDirectory()) {
+        if (absPath === additionalPath || absPath.startsWith(`${additionalPath}${sep}`)) {
+          allowedAdditional = true;
+          break;
+        }
+        continue;
+      }
+      if (s.isFile()) {
+        if (absPath === additionalPath && absPath.endsWith(".md")) {
+          allowedAdditional = true;
+          break;
+        }
+      }
+    } catch {}
+  }
+  if (!allowedWorkspace && !allowedAdditional) throw new Error("path required");
+  if (!absPath.endsWith(".md")) throw new Error("path required");
+  if ((await statRegularFile(absPath)).missing) return { text: "", path: relPath };
+  let content: string;
+  try {
+    content = await readFile(absPath, "utf-8");
+  } catch (err) {
+    if (isFileMissingError(err)) return { text: "", path: relPath };
+    throw err;
+  }
+  if (!params.from && !params.lines) return { text: content, path: relPath };
+  const fileLines = content.split("\n");
+  const start = Math.max(1, params.from ?? 1);
+  const count = Math.max(1, params.lines ?? fileLines.length);
+  return { text: fileLines.slice(start - 1, start - 1 + count).join("\n"), path: relPath };
+}
+
 // ── Ingest sanitization: strip system noise so only real conversations get stored
 // Patterns that indicate system-generated messages (not user conversations)
 const SYSTEM_NOISE_PATTERNS = [
@@ -587,20 +679,19 @@ const memoryRouterPlugin = {
             return;
           }
 
-          // Await the fetch so OpenClaw's runVoidHook keeps the event loop alive.
-          try {
-            const res = await fetch(`${endpoint}/v1/memory/ingest`, {
-              method: "POST",
-              headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${memoryKey}`,
-              },
-              body: JSON.stringify({
-                messages: toStore,
-                model: "unknown",
-                ...(embeddings && { embeddings }),
-              }),
-            });
+          // Fire and forget — don't block message delivery waiting for ingest
+          fetch(`${endpoint}/v1/memory/ingest`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${memoryKey}`,
+            },
+            body: JSON.stringify({
+              messages: toStore,
+              model: "unknown",
+              ...(embeddings && { embeddings }),
+            }),
+          }).then(async (res) => {
             if (!res.ok) {
               const details = await res.text().catch(() => "");
               if (details.includes("payment_required")) {
@@ -612,17 +703,117 @@ const memoryRouterPlugin = {
             } else {
               api.logger.debug?.(`memoryrouter: ingest accepted (${toStore.length} messages)`);
             }
-          } catch (err) {
-            log(
-              `memoryrouter: ingest error — ${err instanceof Error ? err.message : String(err)}`,
-            );
-          }
+          }).catch((err) => {
+            log(`memoryrouter: ingest error — ${err instanceof Error ? err.message : String(err)}`);
+          });
         } catch (err) {
           log(
             `memoryrouter: agent_end error — ${err instanceof Error ? err.message : String(err)}`,
           );
         }
       });
+      // ==================================================================
+      // Tools: memory_search + memory_get (replaces OpenClaw built-in)
+      // ==================================================================
+
+      // memory_search — calls MR /v1/memory/search
+      api.registerTool((ctx) => {
+        return {
+          label: "Memory Search",
+          name: "memory_search",
+          description: "Search memories from past conversations and your workspace. Use when relevant.",
+          parameters: {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+              maxResults: { type: "number" },
+              minScore: { type: "number" },
+            },
+            required: ["query"],
+          } as any,
+          execute: async (_toolCallId: string, params: Record<string, unknown>) => {
+            const query = typeof params.query === "string" ? params.query.trim() : "";
+            if (!query) return jsonToolResult({ results: [], error: "query required" });
+            const limit = typeof params.maxResults === "number" ? params.maxResults : 10;
+            try {
+              const res = await fetch(`${endpoint}/v1/memory/search`, {
+                method: "POST",
+                headers: {
+                  Authorization: `Bearer ${memoryKey}`,
+                  "Content-Type": "application/json",
+                  ...(embeddings && { "X-Embedding-Model": embeddings }),
+                },
+                body: JSON.stringify({ query, limit }),
+              });
+              if (!res.ok) {
+                const errBody = await res.text().catch(() => "");
+                return jsonToolResult({ results: [], error: `Search failed: HTTP ${res.status}`, details: errBody.slice(0, 200) });
+              }
+              const data = await res.json() as {
+                memories?: Array<{ content: string; score: number; role: string; window: string; timestampHuman: string }>;
+                totalMemories?: number;
+                tokenCount?: number;
+              };
+              // Format results similar to OpenClaw's memory_search output
+              const results = (data.memories || []).map((m) => ({
+                snippet: m.content,
+                score: m.score,
+                source: "memoryrouter",
+                role: m.role,
+                window: m.window,
+                date: m.timestampHuman,
+              }));
+              return jsonToolResult({
+                results,
+                totalFound: data.totalMemories || results.length,
+                tokens: data.tokenCount || 0,
+                provider: "memoryrouter",
+                model: embeddings || "bge",
+              });
+            } catch (err) {
+              return jsonToolResult({ results: [], error: err instanceof Error ? err.message : String(err) });
+            }
+          },
+        };
+      });
+
+      // memory_get — exact copy of OpenClaw's implementation (pure local file read)
+      api.registerTool((ctx) => {
+        const workspaceDir = ctx.workspaceDir || "";
+        // Read extraPaths from config even though memorySearch is disabled
+        const memSearchCfg = (ctx.config as any)?.agents?.defaults?.memorySearch;
+        const extraPaths: string[] = memSearchCfg?.extraPaths || [];
+        return {
+          label: "Memory Get",
+          name: "memory_get",
+          description: "Safe snippet read from MEMORY.md or memory/*.md with optional from/lines; use after memory_search to pull only the needed lines and keep context small.",
+          parameters: {
+            type: "object",
+            properties: {
+              path: { type: "string" },
+              from: { type: "number" },
+              lines: { type: "number" },
+            },
+            required: ["path"],
+          } as any,
+          execute: async (_toolCallId: string, params: Record<string, unknown>) => {
+            const relPath = typeof params.path === "string" ? params.path.trim() : "";
+            if (!relPath) return jsonToolResult({ path: "", text: "", error: "path required" });
+            const from = typeof params.from === "number" ? params.from : undefined;
+            const lines = typeof params.lines === "number" ? params.lines : undefined;
+            try {
+              return jsonToolResult(await memoryGetReadFile(workspaceDir, { relPath, from, lines }, extraPaths));
+            } catch (err) {
+              return jsonToolResult({
+                path: relPath,
+                text: "",
+                disabled: true,
+                error: err instanceof Error ? err.message : String(err),
+              });
+            }
+          },
+        };
+      });
     } // end if (memoryKey)
 
     // ==================================================================
@@ -634,12 +825,8 @@ const memoryRouterPlugin = {
     // but keep workspace file search (local, fast, no conflict)
     async function optimizeMemorySearchConfig(): Promise<void> {
       try {
-        // Set sources to only "memory" (workspace files), remove "sessions"
-        await runOpenClawConfigSet("agents.defaults.memorySearch.sources", JSON.stringify(["memory"]), true);
-        // Disable experimental session memory
-        await runOpenClawConfigSet("agents.defaults.memorySearch.experimental.sessionMemory", "false", true);
-        // Disable re-indexing on every search (MR handles memory, no need to re-embed constantly)
-        await runOpenClawConfigSet("agents.defaults.memorySearch.sync.onSearch", "false", true);
+        // Disable built-in memory entirely — MR replaces it with custom tools
+        await runOpenClawConfigSet("agents.defaults.memorySearch.enabled", "false", true);
       } catch {
         // Non-fatal — config optimization is best-effort
       }
@@ -648,8 +835,13 @@ const memoryRouterPlugin = {
     // ── Helper: Restore OpenClaw's built-in memorySearch config when MR is disabled
     async function restoreMemorySearchConfig(): Promise<void> {
       try {
+        // Re-enable built-in memory system
+        await runOpenClawConfigSet("agents.defaults.memorySearch.enabled", "true", true);
+        // Restore full sources (workspace + sessions)
         await runOpenClawConfigSet("agents.defaults.memorySearch.sources", JSON.stringify(["memory", "sessions"]), true);
+        // Restore session memory
         await runOpenClawConfigSet("agents.defaults.memorySearch.experimental.sessionMemory", "true", true);
+        // Restore sync on search
         await runOpenClawConfigSet("agents.defaults.memorySearch.sync.onSearch", "true", true);
       } catch {
         // Non-fatal
@@ -670,8 +862,8 @@ const memoryRouterPlugin = {
             // but disable session transcript scanning (MR handles conversational memory)
             await optimizeMemorySearchConfig();
             console.log(`✓ MemoryRouter enabled. Key: ${key.slice(0, 6)}...${key.slice(-3)}`);
-            console.log(`  • Session memory scanning disabled (MR handles this)`);
-            console.log(`  • Workspace file search kept active`);
+            console.log(`  • Built-in memory disabled (MR fully replaces it)`);
+            console.log(`  • memory_search + memory_get tools registered via plugin`);
             console.log(`\nRun: openclaw mr upload    to upload your memories`);
           } catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -704,7 +896,7 @@ const memoryRouterPlugin = {
               // Restore OpenClaw's built-in session memory scanning
               await restoreMemorySearchConfig();
               console.log("✓ MemoryRouter disabled (key cleared).");
-              console.log("  • Session memory scanning restored");
+              console.log("  • Built-in memory restored (enabled, sessions + workspace)");
               console.log("  • CLI still available — run `openclaw mr <key>` to re-enable");
             } catch (err) {
               console.error(`Failed to disable: ${err instanceof Error ? err.message : String(err)}`);
@@ -728,8 +920,7 @@ const memoryRouterPlugin = {
               if (memoryKey) {
                 console.log("\nRestoring memory settings...");
                 await optimizeMemorySearchConfig();
-                console.log("  ✓ Session memory scanning disabled (MR handles this)");
-                console.log("  ✓ Workspace file search kept active");
+                console.log("  ✓ Built-in memory disabled (MR fully replaces it)");
               }
 
               console.log("\n✅ mr-memory updated. Restart gateway to apply: openclaw gateway restart");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mr-memory",
-  "version": "2.22.2",
+  "version": "3.0.1",
   "description": "MemoryRouter persistent memory plugin for OpenClaw — your AI remembers every conversation",
   "type": "module",
   "files": [