agent-memory-graph 0.3.0 → 0.4.1

package/dist/plugin/entry.js

@@ -5774,6 +5774,63 @@ var entry_default = definePluginEntry({
   name: "Memory Graph",
   description: "Auto-builds a knowledge graph from conversations. Extracts entities/relationships and exposes graph query tools.",
   register(api) {
+    api.on(
+      "before_prompt_build",
+      async (event, ctx) => {
+        const config = ctx?.pluginConfig;
+        if (config?.promptInjection === false) return;
+        try {
+          const graph = await getGraph(config);
+          const stats = graph.stats();
+          if (stats.entities === 0) return;
+          const prompt = event.prompt || "";
+          let contextLines = [];
+          const PRIORITY_TYPES = ["Project", "Person", "Platform", "Organization", "Company", "Event", "System"];
+          const SKIP_TYPES = ["Tool", "Concept", "File", "Award"];
+          if (prompt && prompt.length > 20) {
+            const searchQuery = prompt.slice(0, 100).replace(/[\n\r]+/g, " ").trim();
+            const results = graph.search(searchQuery, 15);
+            if (results.length > 0) {
+              const filtered = results.filter((r) => !SKIP_TYPES.includes(r.entity.type)).sort((a, b) => {
+                const aPriority = PRIORITY_TYPES.indexOf(a.entity.type);
+                const bPriority = PRIORITY_TYPES.indexOf(b.entity.type);
+                const aScore = (aPriority >= 0 ? 100 - aPriority : 50) + (a.relations?.length || 0);
+                const bScore = (bPriority >= 0 ? 100 - bPriority : 50) + (b.relations?.length || 0);
+                return bScore - aScore;
+              }).slice(0, 5);
+              if (filtered.length > 0) {
+                contextLines = filtered.map((r) => {
+                  const rels = r.relations?.filter((rel) => !SKIP_TYPES.includes(rel.targetType || "")).slice(0, 3).map((rel) => `${rel.direction === "outgoing" ? "\u2192" : "\u2190"} ${rel.relation} ${rel.target}`).join(", ") || "";
+                  return `${r.entity.name} (${r.entity.type})${rels ? ": " + rels : ""}`;
+                });
+              }
+            }
+          }
+          if (contextLines.length === 0) {
+            const allEntities = graph.listEntities({ limit: 30, sortBy: "updated_at" });
+            const prioritized = allEntities.filter((e) => !SKIP_TYPES.includes(e.type)).sort((a, b) => {
+              const aPriority = PRIORITY_TYPES.indexOf(a.type);
+              const bPriority = PRIORITY_TYPES.indexOf(b.type);
+              return (bPriority >= 0 ? bPriority : -1) - (aPriority >= 0 ? aPriority : -1);
+            }).slice(0, 5);
+            if (prioritized.length > 0) {
+              contextLines = prioritized.map((e) => `${e.name} (${e.type})`);
+            }
+          }
+          if (contextLines.length === 0) return;
+          const injection = `## Knowledge Graph Context (auto-injected by memory-graph plugin)
+Relevant entities from your knowledge graph:
+${contextLines.join("\n")}
+
+Use memory_graph_query or memory_graph_search tools for more details when needed.`;
+          return { appendContext: injection };
+        } catch (err) {
+          console.warn("[memory-graph] Prompt injection failed:", err.message);
+          return;
+        }
+      },
+      { priority: 10 }
+    );
     api.on(
       "message_received",
       async (event) => {
@@ -5827,6 +5884,58 @@ var entry_default = definePluginEntry({
       },
       { priority: 10 }
     );
+    api.on(
+      "agent_end",
+      async (event, ctx) => {
+        const config = ctx?.pluginConfig;
+        const sessionKey = ctx?.sessionKey || "";
+        const messages = event.messages || [];
+        console.log(`[memory-graph] agent_end fired: sessionKey=${sessionKey}, messages=${messages.length}, success=${event.success}`);
+        if (config?.sessionSummary === false) return;
+        if (!sessionKey) return;
+        const textParts = [];
+        for (const msg of messages) {
+          const role = msg.role || "unknown";
+          if (role !== "user" && role !== "assistant") continue;
+          const text = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((p) => p.type === "text").map((p) => p.text).join(" ") : "";
+          if (!text || text.length < MIN_MEANINGFUL_LENGTH) continue;
+          textParts.push(`[${role}]: ${text.slice(0, 500)}`);
+        }
+        if (textParts.length < 2) return;
+        const transcript = textParts.join("\n").slice(0, 3e3);
+        try {
+          const graph = await getGraph(config);
+          const { OpenAI } = await import("openai");
+          const client = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+            baseURL: process.env.OPENAI_BASE_URL
+          });
+          const summaryResponse = await client.chat.completions.create({
+            model: config?.extractionModel || process.env.MEMORY_GRAPH_MODEL || "kr/claude-haiku-4.5",
+            messages: [
+              {
+                role: "system",
+                content: `You are a session summarizer for a knowledge graph. Given a conversation transcript, extract a 2-4 sentence summary of KEY ACTIONS taken (what was built, fixed, published, decided, configured). Focus on concrete outcomes, versions, platforms, and decisions. Skip casual chat and test/debug noise. If nothing meaningful happened, respond with "NO_SUMMARY". Output plain text only.`
+              },
+              { role: "user", content: transcript }
+            ],
+            max_tokens: 300,
+            temperature: 0.3
+          });
+          const summary = summaryResponse.choices?.[0]?.message?.content?.trim();
+          if (summary && summary !== "NO_SUMMARY" && summary.length >= 20) {
+            const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+            await graph.ingest(summary, { source: `session-summary-${today}`, sessionId: sessionKey });
+            console.log(`[memory-graph] Session summary ingested (${textParts.length} msgs \u2192 ${summary.length} chars)`);
+          } else {
+            console.log(`[memory-graph] No meaningful summary for session (${textParts.length} msgs)`);
+          }
+        } catch (err) {
+          console.warn("[memory-graph] Session summary failed:", err.message);
+        }
+      },
+      { priority: 10 }
+    );
     api.on(
       "session_end",
       async (event, ctx) => {

package/openclaw.plugin.json

@@ -71,6 +71,11 @@
           }
         },
         "default": []
+      },
+      "promptInjection": {
+        "type": "boolean",
+        "description": "Automatically inject relevant graph context into every agent prompt",
+        "default": true
       }
     },
     "additionalProperties": false
@@ -79,7 +84,7 @@
     "openclawVersion": ">=2026.3.24",
     "entry": "dist/plugin/entry.js"
   },
-  "version": "0.1.1",
+  "version": "0.4.1",
   "author": "KLSGG",
   "repository": "https://github.com/KLSGG/agent-memory-graph",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-memory-graph",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Domain-agnostic knowledge graph memory for AI agents. Zero-config, local-first, SQLite-powered. Works as OpenClaw skill (CLI) or plugin (auto-hook).",
   "type": "module",
   "main": "dist/src/index.js",