memory-braid 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-braid",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "OpenClaw memory plugin that augments local memory with Mem0 capture and recall.",
   "type": "module",
   "main": "./src/index.ts",

package/src/entities.ts

@@ -11,6 +11,8 @@ type NerRecord = {
   entity_group?: unknown;
   entity?: unknown;
   score?: unknown;
+  start?: unknown;
+  end?: unknown;
 };
 
 export type ExtractedEntity = {
@@ -79,6 +81,138 @@ function normalizeEntityText(raw: unknown): string {
   return normalizeWhitespace(raw.replace(/^##/, "").replace(/^▁/, ""));
 }
 
+type NormalizedEntityToken = {
+  text: string;
+  type: ExtractedEntity["type"];
+  score: number;
+  start?: number;
+  end?: number;
+};
+
+const ENTITY_CONNECTOR_WORDS = new Set([
+  "and",
+  "da",
+  "de",
+  "del",
+  "la",
+  "las",
+  "los",
+  "of",
+  "the",
+  "y",
+]);
+const ENTITY_MAX_MERGED_WORDS = 3;
+
+function asFiniteNumber(value: unknown): number | undefined {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return undefined;
+  }
+  return value;
+}
+
+function splitEntityWords(text: string): string[] {
+  return text.match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+
+function isLikelyNoisyShortWord(word: string): boolean {
+  const normalized = word.toLowerCase();
+  if (normalized.length >= 3) {
+    return false;
+  }
+  if (ENTITY_CONNECTOR_WORDS.has(normalized)) {
+    return false;
+  }
+  return !/^[A-Z]\.?$/.test(word);
+}
+
+function joinEntityText(left: NormalizedEntityToken, right: NormalizedEntityToken): string {
+  const leftEnd = left.end;
+  const rightStart = right.start;
+  if (typeof leftEnd === "number" && typeof rightStart === "number") {
+    const gap = rightStart - leftEnd;
+    if (gap <= 0) {
+      return `${left.text}${right.text}`;
+    }
+  }
+  return `${left.text} ${right.text}`;
+}
+
+function shouldMergeEntityTokens(
+  left: NormalizedEntityToken,
+  right: NormalizedEntityToken,
+  sourceText?: string,
+): boolean {
+  if (left.type !== right.type || !left.text || !right.text) {
+    return false;
+  }
+
+  const leftWords = splitEntityWords(left.text);
+  const rightWords = splitEntityWords(right.text);
+  if (leftWords.length === 0 || rightWords.length === 0) {
+    return false;
+  }
+  if (leftWords.length + rightWords.length > ENTITY_MAX_MERGED_WORDS) {
+    return false;
+  }
+  const leftLastWord = leftWords[leftWords.length - 1];
+  const rightFirstWord = rightWords[0];
+  if (!leftLastWord || !rightFirstWord) {
+    return false;
+  }
+  if (isLikelyNoisyShortWord(leftLastWord) || isLikelyNoisyShortWord(rightFirstWord)) {
+    return false;
+  }
+
+  const leftEnd = left.end;
+  const rightStart = right.start;
+  if (typeof leftEnd === "number" && typeof rightStart === "number") {
+    const gap = rightStart - leftEnd;
+    if (gap < 0) {
+      return false;
+    }
+    if (gap > 1) {
+      return false;
+    }
+    if (sourceText && gap > 0) {
+      const between = sourceText.slice(leftEnd, rightStart);
+      if (between && /[^\s]/u.test(between)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  if (/[.,!?;:]$/.test(left.text) || /^[.,!?;:]/.test(right.text)) {
+    return false;
+  }
+  return true;
+}
+
+function collapseAdjacentEntityTokens(
+  tokens: NormalizedEntityToken[],
+  sourceText?: string,
+): NormalizedEntityToken[] {
+  if (tokens.length <= 1) {
+    return tokens;
+  }
+
+  const collapsed: NormalizedEntityToken[] = [];
+  for (const token of tokens) {
+    const previous = collapsed[collapsed.length - 1];
+    if (!previous || !shouldMergeEntityTokens(previous, token, sourceText)) {
+      collapsed.push({ ...token });
+      continue;
+    }
+
+    previous.text = normalizeWhitespace(joinEntityText(previous, token));
+    previous.score = Math.min(previous.score, token.score);
+    previous.start = typeof previous.start === "number" ? previous.start : token.start;
+    previous.end = typeof token.end === "number" ? token.end : previous.end;
+  }
+
+  return collapsed;
+}
+
 type EntityExtractionOptions = {
   stateDir?: string;
 };
@@ -319,7 +453,7 @@ export class EntityExtractionManager {
     });
     const rows = Array.isArray(raw) ? raw : [];
 
-    const deduped = new Map<string, ExtractedEntity>();
+    const normalized: NormalizedEntityToken[] = [];
     for (const row of rows) {
       if (!row || typeof row !== "object") {
         continue;
@@ -335,13 +469,25 @@ export class EntityExtractionManager {
       }
 
       const type = normalizeEntityType(record.entity_group ?? record.entity);
-      const canonicalUri = buildCanonicalEntityUri(type, entityText);
+      normalized.push({
+        text: entityText,
+        type,
+        score,
+        start: asFiniteNumber(record.start),
+        end: asFiniteNumber(record.end),
+      });
+    }
+
+    const collapsed = collapseAdjacentEntityTokens(normalized, params.text);
+    const deduped = new Map<string, ExtractedEntity>();
+    for (const token of collapsed) {
+      const canonicalUri = buildCanonicalEntityUri(token.type, token.text);
       const current = deduped.get(canonicalUri);
-      if (!current || score > current.score) {
+      if (!current || token.score > current.score) {
         deduped.set(canonicalUri, {
-          text: entityText,
-          type,
-          score,
+          text: token.text,
+          type: token.type,
+          score: token.score,
           canonicalUri,
         });
       }

package/src/extract.ts

@@ -12,6 +12,34 @@ const HEURISTIC_PATTERNS = [
   /my name is|i am|contact me at|email is|phone is/i,
   /deadline|due date|todo|action item|follow up/i,
 ];
+const HEURISTIC_LOOKBACK_MULTIPLIER = 4;
+const HEURISTIC_MIN_LOOKBACK_MESSAGES = 12;
+const FEED_TAG_PATTERN = /\[(?:n8n|rss|alert|news|cron|slack|discord|telegram|email|github|jira)[^[]*]/i;
+const ROLE_LABEL_PATTERN = /\b(?:assistant|system|tool|developer)\s*:/gi;
+
+function isLikelyFeedOrImportedText(text: string): boolean {
+  if (FEED_TAG_PATTERN.test(text)) {
+    return true;
+  }
+
+  const roleLabels = text.match(ROLE_LABEL_PATTERN)?.length ?? 0;
+  if (roleLabels >= 2) {
+    return true;
+  }
+
+  const lines = text
+    .split(/\r?\n+/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (lines.length === 0) {
+    return false;
+  }
+
+  const rolePrefixedLines = lines.filter((line) =>
+    /^(assistant|system|tool|developer|user)\s*:/i.test(line),
+  ).length;
+  return rolePrefixedLines >= 2;
+}
 
 function extractMessageText(content: unknown): string {
   if (typeof content === "string") {
@@ -98,8 +126,10 @@ function pickHeuristicCandidates(
 ): ExtractedCandidate[] {
   const out: ExtractedCandidate[] = [];
   const seen = new Set<string>();
+  const lookback = Math.max(HEURISTIC_MIN_LOOKBACK_MESSAGES, maxItems * HEURISTIC_LOOKBACK_MULTIPLIER);
+  const startIndex = Math.max(0, messages.length - lookback);
 
-  for (let i = messages.length - 1; i >= 0; i -= 1) {
+  for (let i = messages.length - 1; i >= startIndex; i -= 1) {
     const message = messages[i];
     if (!message || (message.role !== "user" && message.role !== "assistant")) {
       continue;
@@ -107,6 +137,9 @@ function pickHeuristicCandidates(
     if (message.text.length < 20 || message.text.length > 3000) {
       continue;
     }
+    if (isLikelyFeedOrImportedText(message.text)) {
+      continue;
+    }
 
     const score = scoreHeuristic(message.text);
     if (score < 0.2) {

package/src/index.ts

@@ -24,7 +24,7 @@ import {
   writeStatsState,
 } from "./state.js";
 import type { LifecycleEntry, MemoryBraidResult, ScopeKey } from "./types.js";
-import { normalizeForHash, sha256 } from "./chunking.js";
+import { normalizeForHash, normalizeWhitespace, sha256 } from "./chunking.js";
 
 function jsonToolResult(payload: unknown) {
   return {
@@ -225,6 +225,17 @@ function isGenericUserSummary(text: string): boolean {
   );
 }
 
+function sanitizeRecallQuery(text: string): string {
+  if (!text) {
+    return "";
+  }
+  const withoutInjectedMemories = text.replace(
+    /<relevant-memories>[\s\S]*?<\/relevant-memories>/gi,
+    " ",
+  );
+  return normalizeWhitespace(withoutInjectedMemories);
+}
+
 function applyMem0QualityAdjustments(params: {
   results: MemoryBraidResult[];
   query: string;
@@ -1220,6 +1231,10 @@ const memoryBraidPlugin = {
 
     api.on("before_agent_start", async (event, ctx) => {
       const runId = log.newRunId();
+      const recallQuery = sanitizeRecallQuery(event.prompt);
+      if (!recallQuery) {
+        return;
+      }
       const toolCtx: OpenClawPluginToolContext = {
         config: api.config,
         workspaceDir: ctx.workspaceDir,
@@ -1235,17 +1250,17 @@ const memoryBraidPlugin = {
         log,
         ctx: toolCtx,
         statePaths: runtimeStatePaths,
-        query: event.prompt,
+        query: recallQuery,
         args: {
-          query: event.prompt,
+          query: recallQuery,
           maxResults: cfg.recall.maxResults,
         },
         runId,
       });
 
       const selected = selectMemoriesForInjection({
-        query: event.prompt,
-        results: recall.merged,
+        query: recallQuery,
+        results: recall.mem0,
         limit: cfg.recall.injectTopK,
       });
       if (selected.injected.length === 0) {
@@ -1256,6 +1271,7 @@ const memoryBraidPlugin = {
           sessionKey: scope.sessionKey,
           workspaceHash: scope.workspaceHash,
           count: 0,
+          source: "mem0",
           queryTokens: selected.queryTokens,
           filteredOut: selected.filteredOut,
           genericRejected: selected.genericRejected,
@@ -1272,6 +1288,7 @@ const memoryBraidPlugin = {
         sessionKey: scope.sessionKey,
         workspaceHash: scope.workspaceHash,
         count: selected.injected.length,
+        source: "mem0",
         queryTokens: selected.queryTokens,
         filteredOut: selected.filteredOut,
         genericRejected: selected.genericRejected,