@joshuaswarren/openclaw-engram 9.1.24 → 9.1.25

package/dist/access-cli.js

@@ -3,10 +3,10 @@ import {
   EngramAccessService,
   Orchestrator,
   parseConfig
-} from "./chunk-XKT3IT22.js";
-import "./chunk-PIQWOQEX.js";
+} from "./chunk-JUQ752QV.js";
+import "./chunk-MNBCF5B2.js";
 import "./chunk-IMMYYNXG.js";
-import "./chunk-Y6DMH5LN.js";
+import "./chunk-IADQJS2J.js";
 import "./chunk-6KX4XLQJ.js";
 import "./chunk-4722S3A6.js";
 import "./chunk-MKM2BCQH.js";

package/dist/{chunk-Y6DMH5LN.js → chunk-IADQJS2J.js}

@@ -2227,7 +2227,13 @@ ${sanitized.text}
   invalidateAllMemoriesCache() {
     _StorageManager.allMemoriesInFlight.delete(this.baseDir);
   }
-  async _readAllMemoriesFromDisk() {
+  normalizeMemoryReadBatchSize(batchSize) {
+    if (typeof batchSize !== "number" || !Number.isFinite(batchSize)) {
+      return 50;
+    }
+    return Math.max(1, Math.floor(batchSize));
+  }
+  async collectActiveMemoryPaths() {
     const filePaths = [];
     const collectPaths = async (dir) => {
       try {
@@ -2249,11 +2255,14 @@ ${sanitized.text}
     };
     await collectPaths(this.factsDir);
     await collectPaths(this.correctionsDir);
+    return filePaths;
+  }
+  async readParsedMemoriesFromPaths(filePaths, batchSize) {
     if (filePaths.length === 0) return [];
-    const BATCH_SIZE = 50;
+    const normalizedBatchSize = this.normalizeMemoryReadBatchSize(batchSize);
     const memories = [];
-    for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-      const batch = filePaths.slice(i, i + BATCH_SIZE);
+    for (let i = 0; i < filePaths.length; i += normalizedBatchSize) {
+      const batch = filePaths.slice(i, i + normalizedBatchSize);
       const results = await Promise.all(
         batch.map(async (fullPath) => {
           try {
@@ -2273,12 +2282,126 @@ ${sanitized.text}
           }
         })
       );
-      for (const m of results) {
-        if (m !== null) memories.push(m);
+      for (const memory of results) {
+        if (memory !== null) memories.push(memory);
       }
     }
     return memories;
   }
+  async readWindowUpdatedMs(filePath) {
+    try {
+      const raw = await readFile2(filePath, "utf-8");
+      const match = raw.match(/^---\n([\s\S]*?)\n---\n?/);
+      if (!match) return null;
+      const frontmatterBlock = match[1];
+      const rawUpdated = frontmatterBlock.match(/^updated:\s*"?([^"\n]*)"?/m)?.[1] ?? frontmatterBlock.match(/^created:\s*"?([^"\n]*)"?/m)?.[1] ?? null;
+      const updatedMs = rawUpdated ? Date.parse(rawUpdated) : Number.NaN;
+      return Number.isFinite(updatedMs) ? updatedMs : null;
+    } catch {
+      return null;
+    }
+  }
+  async filterWindowPathsByUpdatedAfter(filePaths, updatedAfterMs) {
+    const results = await Promise.all(filePaths.map(async (filePath) => {
+      const updatedMs = await this.readWindowUpdatedMs(filePath);
+      if (updatedMs !== null) {
+        return updatedMs >= updatedAfterMs ? filePath : null;
+      }
+      try {
+        const fileStat = await stat2(filePath);
+        return fileStat.mtimeMs >= updatedAfterMs ? filePath : null;
+      } catch {
+        return filePath;
+      }
+    }));
+    return results.filter((filePath) => filePath !== null);
+  }
+  orderWindowPaths(filePaths) {
+    const correctionPaths = [];
+    const factPaths = [];
+    for (const filePath of filePaths) {
+      if (filePath === this.correctionsDir || filePath.startsWith(`${this.correctionsDir}${path4.sep}`)) {
+        correctionPaths.push(filePath);
+      } else {
+        factPaths.push(filePath);
+      }
+    }
+    correctionPaths.sort((left, right) => right.localeCompare(left));
+    factPaths.sort((left, right) => right.localeCompare(left));
+    if (correctionPaths.length === 0) return factPaths;
+    if (factPaths.length === 0) return correctionPaths;
+    const ordered = [];
+    const maxLength = Math.max(correctionPaths.length, factPaths.length);
+    for (let i = 0; i < maxLength; i += 1) {
+      const correctionPath = correctionPaths[i];
+      if (correctionPath) ordered.push(correctionPath);
+      const factPath = factPaths[i];
+      if (factPath) ordered.push(factPath);
+    }
+    return ordered;
+  }
+  async readWindowBoundedBatch(candidateBatchPaths, remainingSlots, remainingInspectionBudget, readBatchSize) {
+    const memories = [];
+    const filePaths = [];
+    const normalizedReadBatchSize = this.normalizeMemoryReadBatchSize(readBatchSize);
+    for (let index = 0; index < candidateBatchPaths.length; ) {
+      if (memories.length >= remainingSlots || filePaths.length >= remainingInspectionBudget) break;
+      const availableSlots = remainingSlots - memories.length;
+      const availableInspectionBudget = remainingInspectionBudget - filePaths.length;
+      const parallelWindow = availableSlots >= 4 && availableInspectionBudget >= 4 ? Math.min(normalizedReadBatchSize, 4) : 1;
+      const candidatePaths = candidateBatchPaths.slice(
+        index,
+        index + Math.min(parallelWindow, availableInspectionBudget)
+      );
+      index += candidatePaths.length;
+      if (candidatePaths.length === 0) break;
+      filePaths.push(...candidatePaths);
+      const parsedMemories = await this.readParsedMemoriesFromPaths(candidatePaths, candidatePaths.length);
+      if (parsedMemories.length === 0) continue;
+      memories.push(...parsedMemories.slice(0, availableSlots));
+    }
+    return { memories, filePaths };
+  }
+  async readMemoriesWindow(options = {}) {
+    const allPaths = await this.collectActiveMemoryPaths();
+    const sortedPaths = this.orderWindowPaths(allPaths);
+    const maxMemories = typeof options.maxMemories === "number" && Number.isFinite(options.maxMemories) ? Math.max(1, Math.floor(options.maxMemories)) : void 0;
+    const maxCandidatePaths = maxMemories === void 0 ? void 0 : maxMemories * 2;
+    const updatedAfterMs = options.updatedAfter?.getTime();
+    const normalizedBatchSize = this.normalizeMemoryReadBatchSize(options.batchSize);
+    const memories = [];
+    const selectedPaths = [];
+    for (let i = 0; i < sortedPaths.length; i += normalizedBatchSize) {
+      if (maxMemories !== void 0 && (memories.length >= maxMemories || maxCandidatePaths !== void 0 && selectedPaths.length >= maxCandidatePaths)) {
+        return { memories, filePaths: selectedPaths };
+      }
+      const batchPaths = sortedPaths.slice(i, i + normalizedBatchSize);
+      const candidateBatchPaths = updatedAfterMs === void 0 ? batchPaths : await this.filterWindowPathsByUpdatedAfter(batchPaths, updatedAfterMs);
+      const remainingSlots = maxMemories === void 0 ? void 0 : Math.max(0, maxMemories - memories.length);
+      const remainingInspectionBudget = maxCandidatePaths === void 0 ? void 0 : Math.max(0, maxCandidatePaths - selectedPaths.length);
+      const { memories: batchMemories, filePaths: parsedCandidatePaths } = remainingSlots === void 0 ? {
+        memories: await this.readParsedMemoriesFromPaths(candidateBatchPaths, normalizedBatchSize),
+        filePaths: candidateBatchPaths
+      } : await this.readWindowBoundedBatch(
+        candidateBatchPaths,
+        remainingSlots,
+        remainingInspectionBudget ?? remainingSlots,
+        normalizedBatchSize
+      );
+      selectedPaths.push(...parsedCandidatePaths);
+      for (const memory of batchMemories) {
+        memories.push(memory);
+        if (maxMemories !== void 0 && memories.length >= maxMemories) {
+          return { memories, filePaths: selectedPaths };
+        }
+      }
+    }
+    return { memories, filePaths: selectedPaths };
+  }
+  async _readAllMemoriesFromDisk() {
+    const filePaths = await this.collectActiveMemoryPaths();
+    return this.readParsedMemoriesFromPaths(filePaths, 50);
+  }
   /**
    * Read archived memory markdown files under archive/.
    * Used by long-term recall fallback when hot recall has no hits.
@@ -4088,4 +4211,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-Y6DMH5LN.js.map
+//# sourceMappingURL=chunk-IADQJS2J.js.map