@joshuaswarren/openclaw-engram 9.1.9 → 9.1.11

package/dist/access-cli.js

@@ -3,10 +3,10 @@ import {
   EngramAccessService,
   Orchestrator,
   parseConfig
-} from "./chunk-OQOCVPYG.js";
-import "./chunk-UO4TIAAW.js";
+} from "./chunk-YZHFUT42.js";
+import "./chunk-FTVSHYLO.js";
 import "./chunk-IMMYYNXG.js";
-import "./chunk-YKWJUR3I.js";
+import "./chunk-CYO77OAP.js";
 import "./chunk-6KX4XLQJ.js";
 import "./chunk-XCAYYSI7.js";
 import "./chunk-MKM2BCQH.js";

package/dist/{chunk-YKWJUR3I.js → chunk-CYO77OAP.js}

@@ -9,6 +9,75 @@ import { appendFileSync, mkdirSync, statSync } from "fs";
 import { createHash } from "crypto";
 import path4 from "path";
 
+// src/memory-cache.ts
+var entityCacheByDir = /* @__PURE__ */ new Map();
+function getCachedEntities(baseDir, currentVersion) {
+  if (currentVersion === 0) return null;
+  const entry = entityCacheByDir.get(baseDir);
+  if (!entry || entry.version !== currentVersion) return null;
+  return entry.entities;
+}
+function setCachedEntities(baseDir, entities, version) {
+  entityCacheByDir.set(baseDir, { entities, version, loadedAt: Date.now() });
+}
+var episodeMapByDir = /* @__PURE__ */ new Map();
+var ruleMemoriesByDir = /* @__PURE__ */ new Map();
+function getCachedEpisodeMap(baseDir, currentVersion) {
+  if (currentVersion === 0) return null;
+  const entry = episodeMapByDir.get(baseDir);
+  if (!entry || entry.sourceVersion !== currentVersion) return null;
+  return entry.data;
+}
+function setCachedEpisodeMap(baseDir, memories, version) {
+  const map = /* @__PURE__ */ new Map();
+  for (const m of memories) {
+    if (m.frontmatter.status === "archived") continue;
+    if (m.frontmatter.memoryKind !== "episode") continue;
+    map.set(m.frontmatter.id, m);
+  }
+  episodeMapByDir.set(baseDir, { data: map, sourceVersion: version });
+  return map;
+}
+function getCachedRuleMemories(baseDir, currentVersion) {
+  if (currentVersion === 0) return null;
+  const entry = ruleMemoriesByDir.get(baseDir);
+  if (!entry || entry.sourceVersion !== currentVersion) return null;
+  return entry.data;
+}
+function setCachedRuleMemories(baseDir, memories, version) {
+  const byId = /* @__PURE__ */ new Map();
+  const all = [];
+  for (const m of memories) {
+    byId.set(m.frontmatter.id, m);
+    if (m.frontmatter.category === "rule" && m.frontmatter.status !== "archived") {
+      all.push(m);
+    }
+  }
+  const result = { all, byId };
+  ruleMemoriesByDir.set(baseDir, { data: result, sourceVersion: version });
+  return result;
+}
+var QMD_CACHE_TTL_MS = 6e4;
+var qmdSearchCache = /* @__PURE__ */ new Map();
+function getCachedQmdSearch(cacheKey) {
+  const entry = qmdSearchCache.get(cacheKey);
+  if (!entry) return null;
+  if (Date.now() - entry.cachedAt > QMD_CACHE_TTL_MS) {
+    qmdSearchCache.delete(cacheKey);
+    return null;
+  }
+  return entry.results;
+}
+function setCachedQmdSearch(cacheKey, results) {
+  qmdSearchCache.set(cacheKey, { results, cachedAt: Date.now() });
+  if (qmdSearchCache.size > 200) {
+    const now = Date.now();
+    for (const [key, entry] of qmdSearchCache) {
+      if (now - entry.cachedAt > QMD_CACHE_TTL_MS) qmdSearchCache.delete(key);
+    }
+  }
+}
+
 // src/hygiene.ts
 import { mkdir, readFile, stat, writeFile } from "fs/promises";
 import path from "path";
@@ -2051,6 +2120,7 @@ ${sanitized.text}
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
     await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
     this.invalidateKnowledgeIndexCache();
+    this.bumpMemoryStatusVersion();
     log.debug(`wrote entity ${normalized}`);
     return normalized;
   }
@@ -3378,6 +3448,7 @@ ${reflection}
     entity.updated = (/* @__PURE__ */ new Date()).toISOString();
     await writeFile2(filePath, serializeEntityFile(entity), "utf-8");
     this.invalidateKnowledgeIndexCache();
+    this.bumpMemoryStatusVersion();
   }
   // ---------------------------------------------------------------------------
   // Scoring + Knowledge Index (Knowledge Graph v7.0)
@@ -3387,6 +3458,9 @@ ${reflection}
    * Parsing is fast (~50-100ms for ~1,800 files) since entity files are small.
    */
   async readAllEntityFiles() {
+    const currentVersion = this.getMemoryStatusVersion();
+    const cached = getCachedEntities(this.baseDir, currentVersion);
+    if (cached) return cached;
     try {
       const entries = await readdir(this.entitiesDir);
       const mdFiles = entries.filter((e) => e.endsWith(".md"));
@@ -3404,6 +3478,7 @@ ${reflection}
           if (content !== null) entities.push(parseEntityFile(content));
         }
       }
+      setCachedEntities(this.baseDir, entities, currentVersion);
       return entities;
     } catch {
       return [];
@@ -3980,6 +4055,12 @@ ${memory.content}
 
 export {
   sanitizeMemoryContent,
+  getCachedEpisodeMap,
+  setCachedEpisodeMap,
+  getCachedRuleMemories,
+  setCachedRuleMemories,
+  getCachedQmdSearch,
+  setCachedQmdSearch,
   lintWorkspaceFiles,
   rotateMarkdownFileToArchive,
   confidenceTier,
@@ -4007,4 +4088,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-YKWJUR3I.js.map
+//# sourceMappingURL=chunk-CYO77OAP.js.map