openclaw-plugin-memory-engine 4.5.0 → 4.5.1

package/dist/admin.js

@@ -1,3 +1,4 @@
+import { embed } from "./embeddings.js";
 import { Type } from "typebox";
 const T = Type;
 const NL = String.fromCharCode(10);
@@ -133,12 +134,40 @@ export function buildAdminDefs(db) {
         },
         {
             name: "memory_find_similar",
-            description: "Find atoms similar to a reference atom. Uses embeddings when available, FTS title/body overlap otherwise.",
+            description: "Find atoms similar to a reference atom. Semantic via embeddings (cosine) with FTS fallback.",
             parameters: T.Object({ atom_id: T.String(), limit: T.Optional(T.Number()) }),
-            execute: (a) => {
-                const ref = q1("SELECT * FROM atoms WHERE id=?", a.atom_id);
+            execute: async (a) => {
+                const ref = q1("SELECT id, title, COALESCE(body_compact, body, '') body, domain FROM atoms WHERE id=?", a.atom_id);
                 if (!ref)
                     return { error: "atom not found" };
+                // 1) semantica: embedding del riferimento + coseno su atom_embeddings (parita' Python find_similar_atoms)
+                const refEmb = await embed(String(ref.title) + ". " + String(ref.body || "").slice(0, 1500));
+                if (refEmb) {
+                    const rows = db.prepare("SELECT e.atom_id id, e.embedding, a.title, a.status, a.domain FROM atom_embeddings e JOIN atoms a ON a.id = e.atom_id WHERE a.status='active' AND e.atom_id != ?").all(ref.id);
+                    const scored = [];
+                    let skippedCorrupt = 0;
+                    for (const r of rows) {
+                        const buf = Buffer.isBuffer(r.embedding) ? r.embedding : Buffer.from(r.embedding?.buffer ?? r.embedding);
+                        if (!buf || !buf.length || buf.length % 4 !== 0 || buf.length / 4 !== refEmb.length) {
+                            skippedCorrupt++;
+                            continue;
+                        }
+                        const v = new Float32Array(buf.buffer, buf.byteOffset, buf.length / 4);
+                        let dot = 0, na = 0, nb = 0;
+                        for (let i = 0; i < v.length; i++) {
+                            dot += refEmb[i] * v[i];
+                            na += refEmb[i] * refEmb[i];
+                            nb += v[i] * v[i];
+                        }
+                        const cos = na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+                        if (cos > 0.55)
+                            scored.push({ id: r.id, title: r.title, domain: r.domain, score: Math.round(cos * 10000) / 10000 });
+                    }
+                    scored.sort((p2, c) => c.score - p2.score);
+                    if (scored.length)
+                        return { reference: ref.id, mode: "semantic", skipped_corrupt: skippedCorrupt, similar: scored.slice(0, a.limit ?? 5) };
+                }
+                // 2) fallback FTS (ollama down o nessun embedding sopra soglia)
                 const words = String(ref.title || "").toLowerCase().split(/[^a-z0-9_]+/).filter((w) => w.length > 3);
                 const out = [];
                 const seen = new Set([ref.id]);
@@ -157,7 +186,7 @@ export function buildAdminDefs(db) {
                         out.push({ id: h.id, title: h.title, score: h.score });
                     }
                 }
-                return { reference: ref.id, mode: "fts (semantic embeddings: step 2)", similar: out.slice(0, a.limit ?? 5) };
+                return { reference: ref.id, mode: refEmb ? "fts (no embeddings above threshold)" : "fts-fallback (ollama non raggiungibile)", similar: out.slice(0, a.limit ?? 5) };
             },
         },
         {

package/dist/embeddings.js

@@ -32,6 +32,23 @@ function cosine(a, b) {
         return 0;
     return dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
+// cache vettori Float32Array per atom_id (evita riconversione buffer a ogni query)
+const _vecCache = new Map();
+const VEC_CACHE_MAX = 20000;
+function _cachedVec(id, buf) {
+    if (!buf || !buf.length || buf.length % 4 !== 0)
+        return null;
+    const hit = _vecCache.get(id);
+    if (hit && hit.byteLength === buf.length)
+        return hit;
+    if (_vecCache.size >= VEC_CACHE_MAX)
+        _vecCache.clear();
+    const v = new Float32Array(buf.buffer, buf.byteOffset, buf.length / 4);
+    _vecCache.set(id, v);
+    return v;
+}
+// penalita' di dominio allineate all'engine FTS (session/daily inquinano la semantica)
+const DOMAIN_PENALTY = [["session/", -0.05], ["daily/", -0.05]];
 export async function semanticSearch(db, query, limit = 10, domain) {
     const qv = await embed(query);
     if (!qv)
@@ -47,16 +64,28 @@ export async function semanticSearch(db, query, limit = 10, domain) {
         if (domain && r.domain !== domain)
             continue;
         const buf = Buffer.isBuffer(r.embedding) ? r.embedding : Buffer.from(r.embedding?.buffer ?? r.embedding);
-        if (!buf || !buf.length || buf.length % 4 !== 0 || buf.length / 4 !== qv.length) {
+        const v = _cachedVec(r.id, buf);
+        if (!v || v.length !== qv.length) {
             skippedCorrupt++;
             continue;
         } // riga anomala: dimensione incoerente, scartata e conteggiata
-        const v = new Float32Array(buf.buffer, buf.byteOffset, buf.length / 4);
-        scored.push({ id: r.id, title: r.title, domain: r.domain, type: r.type, semantic_score: Math.round(cosine(qv, v) * 10000) / 10000 });
+        let score = cosine(qv, v);
+        for (const [pfx, pen] of DOMAIN_PENALTY) {
+            if (String(r.domain || "").startsWith(pfx)) {
+                score += pen;
+                break;
+            }
+        }
+        scored.push({ id: r.id, title: r.title, domain: r.domain, type: r.type, semantic_score: Math.round(score * 10000) / 10000 });
     }
     semanticSearch._lastSkippedCorrupt = skippedCorrupt;
     scored.sort((a, b) => b.semantic_score - a.semantic_score);
-    return scored.slice(0, limit);
+    // cutoff relativo: i punteggi nomic sono compressi (0.5-0.75); un top-N fisso mescola
+    // risultati rilevanti e rumore distanti pochi centesimi. Teniamo solo cio' che sta
+    // vicino al migliore, come fa un occhio umano a scartare i risultati "di riempimento".
+    const top = scored[0]?.semantic_score ?? 0;
+    const kept = scored.filter((s) => s.semantic_score >= top - 0.05);
+    return kept.slice(0, limit);
 }
 export async function embedAtom(db, atomId, text) {
     const v = await embed(text);

package/dist/entry.js

@@ -53,6 +53,7 @@ export default definePluginEntry({
         const defs = [
             { name: "memory_version", description: "Memory Engine TS version.", parameters: T.Object({}), execute: () => me.version() },
             { name: "memory_recall", description: "Smart recall of past memories. Query short and specific. semantic=true merges embedding search.", parameters: T.Object({ query: T.String(), limit: T.Optional(T.Number()), domain: T.Optional(T.String()), semantic: T.Optional(T.Boolean()) }), execute: (a) => me.recall(a.query, a.limit ?? 5, a.domain, a.semantic ?? false) },
+            { name: "memory_recall_session", description: "Recall messages from a specific OpenClaw session (search within session/ domain atoms).", parameters: T.Object({ session_id: T.String(), query: T.String(), limit: T.Optional(T.Number()) }), execute: (a) => me.recall_session(a.session_id, a.query, a.limit ?? 10) },
             { name: "memory_remember", description: "Save a durable memory (fact, decision, procedure, preference).", parameters: T.Object({ title: T.String(), content: T.String(), type: T.Optional(T.String()), domain: T.Optional(T.String()), confidence: T.Optional(T.Number()) }), execute: (a) => me.remember(a.title, a.content, a.type ?? "fact", a.domain ?? "general", a.confidence ?? 0.8) },
             { name: "memory_working_set", description: "Task context pack with token budget.", parameters: T.Object({ query: T.String(), domain: T.Optional(T.String()), limit: T.Optional(T.Number()), token_budget: T.Optional(T.Number()) }), execute: (a) => me.working_set(a.query, a.domain, a.limit ?? 8, a.token_budget ?? 2000) },
             { name: "memory_get_atom", description: "Full atom by id.", parameters: T.Object({ id: T.String() }), execute: (a) => me.get_atom(a.id) },

package/dist/parity451.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/parity451.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it, beforeAll } from "vitest";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createTools } from "./tools.js";
+import { buildAdminDefs } from "./admin.js";
+describe("parità 4.5.1: recall_session + find_similar", () => {
+    let me, findSimilar;
+    beforeAll(() => {
+        const dir = mkdtempSync(join(tmpdir(), "me-p451-"));
+        process.env.MEMORY_DB_PATH = join(dir, "memory.db");
+        me = createTools(process.env.MEMORY_DB_PATH);
+        const db = me.__db;
+        const now = Math.floor(Date.now() / 1000);
+        db.prepare("CREATE TABLE IF NOT EXISTS atoms (id TEXT PRIMARY KEY, title TEXT, domain TEXT, type TEXT, status TEXT, confidence REAL, access_count INTEGER, weight REAL, body TEXT, body_compact TEXT, tags TEXT, meta TEXT, created_at INTEGER, updated_at INTEGER, accessed_at INTEGER)").run();
+        db.prepare("CREATE TABLE IF NOT EXISTS human_questions (id TEXT PRIMARY KEY, atom_ids TEXT, question_type TEXT, question TEXT, options TEXT, meta TEXT, status TEXT, answer TEXT, answered_at INTEGER, created_at INTEGER)").run();
+        db.prepare("CREATE TABLE IF NOT EXISTS bonds (from_id TEXT, to_id TEXT, relation TEXT, strength REAL, evidence TEXT, created_at INTEGER)").run();
+        db.prepare("CREATE VIRTUAL TABLE IF NOT EXISTS atoms_fts USING fts5(title, body, content='atoms', content_rowid='rowid')").run();
+        db.prepare("CREATE TABLE IF NOT EXISTS atom_embeddings (atom_id TEXT PRIMARY KEY, embedding BLOB, model TEXT, dim INTEGER, created_at INTEGER, updated_at INTEGER)").run();
+        const ins = db.prepare("INSERT INTO atoms (id, title, domain, type, status, confidence, access_count, weight, body, created_at, updated_at, accessed_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)");
+        ins.run("s1-msg1", "Configurazione UPS NUT", "session/testsess", "session_msg", "active", 0.8, 1, 0.5, "abbiamo fermato il container nut-upsd e mascherato il NUT nativo", now, now, now);
+        ins.run("s1-msg2", "Diagnosi NAS rumoroso", "session/testsess", "session_msg", "active", 0.8, 1, 0.5, "il rumore era causato dal restart loop del container", now, now, now);
+        ins.run("other1", "Ricetta carbonara", "cucina", "fact", "active", 0.9, 2, 0.7, "guanciale, uova, pecorino, pepe nero", now, now, now);
+        db.prepare("INSERT INTO atoms_fts(atoms_fts) VALUES('rebuild')").run();
+        findSimilar = buildAdminDefs(db).find((d) => d.name === "memory_find_similar");
+    });
+    it("recall_session trova solo atomi del dominio session/testsess", async () => {
+        const res = await me.recall_session("testsess", "container NUT");
+        expect(Array.isArray(res)).toBe(true);
+        expect(res.length).toBeGreaterThan(0);
+        expect(res.every((r) => r.domain === "session/testsess")).toBe(true);
+    });
+    it("find_similar senza ollama: fallback FTS e mai crash", async () => {
+        const res = await findSimilar.execute({ atom_id: "s1-msg1", limit: 3 });
+        expect(res.reference).toBe("s1-msg1");
+        expect(typeof res.mode).toBe("string");
+        expect(Array.isArray(res.similar)).toBe(true);
+    });
+    it("find_similar su atomo inesistente: errore pulito", async () => {
+        const res = await findSimilar.execute({ atom_id: "non-esiste" });
+        expect(res.error).toBe("atom not found");
+    });
+});

package/dist/tools.d.ts

@@ -4,7 +4,8 @@
  * Python server and are exposed as explicit pointers.
  */
 import { DatabaseSync } from "node:sqlite";
-export declare const VERSION = "4.5.0";
+import { Row } from "./engine.js";
+export declare const VERSION = "4.5.1";
 export declare function createTools(dbPath: string): {
     __db: DatabaseSync;
     version: () => {
@@ -31,6 +32,7 @@ export declare function createTools(dbPath: string): {
         semantic_score: null;
         note: string;
     }[]>;
+    recall_session: (session_id: string, query: string, limit?: number) => Promise<Row[]>;
     remember: (title: string, content: string, type?: string, domain?: string, confidence?: number, tags?: string[]) => {
         id: string;
         title: string;

package/dist/tools.js

@@ -6,7 +6,7 @@
 import { DatabaseSync } from "node:sqlite";
 import { Engine } from "./engine.js";
 import { buildSessionDigest } from "./digest.js";
-export const VERSION = "4.5.0";
+export const VERSION = "4.5.1";
 export function createTools(dbPath) {
     const db = new DatabaseSync(dbPath);
     const engine = new Engine(db, {});
@@ -39,6 +39,10 @@ export function createTools(dbPath) {
             // fallback FTS se ollama non raggiungibile
             return engine.searchFts(query, limit, ["active"]).map((r) => ({ id: r.id, title: r.title, semantic_score: null, note: "fts-fallback (ollama non raggiungibile)" }));
         },
+        recall_session: async (session_id, query, limit = 10) => {
+            // parità Python recall_session: recall limitato al dominio della sessione
+            return engine.recall(query, limit, { domain: "session/" + session_id, semantic: false });
+        },
         remember: (title, content, type = "fact", domain = "general", confidence = 0.8, tags = []) => {
             const now = Math.floor(Date.now() / 1000);
             const id = title.toLowerCase().replace(/[^a-z0-9_\\s]/g, "").trim().replace(/[\\s_]+/g, "_").slice(0, 60) || "atom_" + now;
@@ -256,6 +260,6 @@ export function createTools(dbPath) {
             return { created: true, ...draft };
         },
         // ── Admin jobs: puntano al server Python ──
-        _admin_note: () => "curator_run, learning_run, decay_run, backup/restore, import/export, cleanup_*, reindex_embeddings, find_similar, suggest_bonds: disponibili sul server MCP Python.",
+        _admin_note: () => "curator_run, learning_run, decay_run, backup/restore, import/export, cleanup_*, reindex_embeddings, find_similar, suggest_bonds: tutti disponibili come tool nativi memory_* (parità completa dal 4.5.x).",
     };
 }

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "memory-engine",
   "name": "Memory Engine",
   "description": "Native Memory Engine: 45 memory tools, session ingest/digest, curator and Control UI.",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "configSchema": {
     "type": "object",
     "properties": {
@@ -78,7 +78,8 @@
       "memory_import_markdown",
       "memory_learning_run",
       "memory_ask_pending",
-      "memory_answer_human"
+      "memory_answer_human",
+      "memory_recall_session"
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-plugin-memory-engine",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json && openclaw plugins build",