@xdarkicex/openclaw-memory-libravdb 1.6.4 → 1.6.6

package/dist/identity.js

@@ -56,7 +56,7 @@ function writeIdentityFile(path, userId, parts) {
     const dir = dirname(path);
     mkdirSync(dir, { recursive: true });
     const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-    writeFileSync(tmp, JSON.stringify(identity, null, 2) + "\n");
+    writeFileSync(tmp, JSON.stringify(identity, null, 2) + "\n", { mode: 0o600 });
     renameSync(tmp, path);
 }
 export function resolveIdentity(params) {

package/dist/index.js

@@ -25033,7 +25033,7 @@ function writeIdentityFile(path4, userId, parts) {
   const dir = dirname(path4);
   mkdirSync(dir, { recursive: true });
   const tmp = `${path4}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`;
-  writeFileSync(tmp, JSON.stringify(identity, null, 2) + "\n");
+  writeFileSync(tmp, JSON.stringify(identity, null, 2) + "\n", { mode: 384 });
   renameSync(tmp, path4);
 }
 function resolveIdentity(params) {
@@ -33471,8 +33471,79 @@ function isMarkdownFile(fileName) {
   return lower.endsWith(".md") || lower.endsWith(".markdown");
 }
 function matchesGlob(value, pattern) {
-  const escaped = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
-  return new RegExp(`^${escaped}$`).test(value);
+  const len = pattern.length;
+  let re = "";
+  let i = 0;
+  while (i < len) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      i += 2;
+      if (pattern[i] === "/") {
+        i++;
+        re += "(?:[^/]+/)*";
+      } else {
+        re += ".*?";
+      }
+    } else if (ch === "*") {
+      re += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      re += "[^/]";
+      i++;
+    } else if (ch === "[") {
+      const end = pattern.indexOf("]", i + 1);
+      if (end === -1) {
+        re += "\\[";
+        i++;
+      } else {
+        const cls = pattern.slice(i + 1, end).replace(/^!/, "^");
+        re += "[" + cls + "]";
+        i = end + 1;
+      }
+    } else if (ch === "{") {
+      const end = pattern.indexOf("}", i + 1);
+      if (end === -1) {
+        re += "\\{";
+        i++;
+      } else {
+        const inner = pattern.slice(i + 1, end);
+        const alternatives = inner.split(",").map((s) => globToRegexFragment(s)).join("|");
+        re += "(?:" + alternatives + ")";
+        i = end + 1;
+      }
+    } else {
+      re += ch.replace(/[.+^${}()|\\]/g, "\\$&");
+      i++;
+    }
+  }
+  return new RegExp(`^${re}$`).test(value);
+}
+function globToRegexFragment(pattern) {
+  const len = pattern.length;
+  let re = "";
+  let i = 0;
+  while (i < len) {
+    const ch = pattern[i];
+    if (ch === "*" && pattern[i + 1] === "*") {
+      i += 2;
+      if (pattern[i] === "/") {
+        i++;
+        re += "(?:[^/]+/)*";
+      } else {
+        re += ".*?";
+      }
+    } else if (ch === "*") {
+      re += "[^/]*";
+      i++;
+    } else if (ch === "?") {
+      re += "[^/]";
+      i++;
+    } else {
+      re += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      i++;
+    }
+  }
+  return re;
 }
 function matchesExcludedDirectory(relativeDir, pattern) {
   const normalized = relativeDir.replace(/\/+$/, "");

package/dist/markdown-ingest.d.ts

@@ -45,4 +45,5 @@ export interface MarkdownIngestionSnapshot {
     mtimeMs: number;
 }
 export declare function createMarkdownIngestionHandle(cfg: PluginConfig, getClient: ClientGetter, logger?: LoggerLike, fsApi?: FsApi): MarkdownIngestionHandle;
+export declare function matchesGlob(value: string, pattern: string): boolean;
 export {};

package/dist/markdown-ingest.js

@@ -803,12 +803,111 @@ function isMarkdownFile(fileName) {
     const lower = fileName.toLowerCase();
     return lower.endsWith(".md") || lower.endsWith(".markdown");
 }
-function matchesGlob(value, pattern) {
-    const escaped = pattern
-        .split("*")
-        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
-        .join(".*");
-    return new RegExp(`^${escaped}$`).test(value);
+export function matchesGlob(value, pattern) {
+    // Convert a glob pattern to a RegExp, supporting:
+    //   **/  — match zero or more path segments
+    //   **   — match any path (including /)
+    //   *   — match within a single segment (no slashes)
+    //   ?   — match a single character (no slashes)
+    //   [...] — character classes (including [!...] negation → [^...])
+    //   {a,b} — brace expansion (comma-separated alternatives)
+    // Anything else is matched literally.
+    const len = pattern.length;
+    let re = "";
+    let i = 0;
+    while (i < len) {
+        const ch = pattern[i];
+        if (ch === "*" && pattern[i + 1] === "*") {
+            i += 2;
+            if (pattern[i] === "/") {
+                // **/ — zero or more complete path segments ending in /
+                i++; // consume the /
+                re += "(?:[^/]+/)*";
+            }
+            else {
+                // standalone ** — match any path including /
+                re += ".*?";
+            }
+        }
+        else if (ch === "*") {
+            // * matches anything except /
+            re += "[^/]*";
+            i++;
+        }
+        else if (ch === "?") {
+            // ? matches a single character except /
+            re += "[^/]";
+            i++;
+        }
+        else if (ch === "[") {
+            // Character class — find the closing ]
+            const end = pattern.indexOf("]", i + 1);
+            if (end === -1) {
+                // No closing bracket, treat literally
+                re += "\\[";
+                i++;
+            }
+            else {
+                // Translate glob [!...] negation to regex [^...] notation
+                const cls = pattern.slice(i + 1, end).replace(/^!/, "^");
+                re += "[" + cls + "]";
+                i = end + 1;
+            }
+        }
+        else if (ch === "{") {
+            // Brace expansion {a,b} → (?:a|b)
+            const end = pattern.indexOf("}", i + 1);
+            if (end === -1) {
+                re += "\\{";
+                i++;
+            }
+            else {
+                const inner = pattern.slice(i + 1, end);
+                const alternatives = inner.split(",").map((s) => globToRegexFragment(s)).join("|");
+                re += "(?:" + alternatives + ")";
+                i = end + 1;
+            }
+        }
+        else {
+            // Literal character — escape regex metacharacters
+            re += ch.replace(/[.+^${}()|\\]/g, "\\$&");
+            i++;
+        }
+    }
+    return new RegExp(`^${re}$`).test(value);
+}
+function globToRegexFragment(pattern) {
+    // Minimal version of matchesGlob for use inside brace expansions.
+    // Supports *, **, ?, and literal characters (no nested braces/classes).
+    const len = pattern.length;
+    let re = "";
+    let i = 0;
+    while (i < len) {
+        const ch = pattern[i];
+        if (ch === "*" && pattern[i + 1] === "*") {
+            i += 2;
+            if (pattern[i] === "/") {
+                i++;
+                re += "(?:[^/]+/)*";
+            }
+            else {
+                re += ".*?";
+            }
+        }
+        else if (ch === "*") {
+            re += "[^/]*";
+            i++;
+        }
+        else if (ch === "?") {
+            re += "[^/]";
+            i++;
+        }
+        else {
+            re += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+            i++;
+        }
+    }
+    return re;
 }
 function matchesExcludedDirectory(relativeDir, pattern) {
     const normalized = relativeDir.replace(/\/+$/, "");

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
   "description": "Persistent vector memory with three-tier hybrid scoring",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "kind": [
     "memory",
     "context-engine"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",