@joshuaswarren/openclaw-engram 9.2.3 → 9.2.4

package/dist/access-cli.js

@@ -3,7 +3,7 @@ import {
   EngramAccessService,
   Orchestrator,
   parseConfig
-} from "./chunk-RITRBWEK.js";
+} from "./chunk-JH4LLA7O.js";
 import "./chunk-YZG2OWZQ.js";
 import "./chunk-IMMYYNXG.js";
 import "./chunk-TUH5NNZ2.js";

package/dist/{chunk-RITRBWEK.js → chunk-JH4LLA7O.js}

@@ -32431,6 +32431,111 @@ var EngramAccessService = class {
       lcmEnabled: true
     };
   }
+  // ── Parity tools (match OpenClaw plugin feature set) ──────────────────
+  async memorySearch(request) {
+    const { query, namespace, maxResults, collection, principal } = request;
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const namespaceFilter = resolvedNs !== this.orchestrator.config.defaultNamespace ? resolvedNs : void 0;
+    const results = collection === "global" ? (await this.orchestrator.qmd.searchGlobal(query, maxResults)).filter(
+      (r) => namespaceFilter ? r.path.includes(`/namespaces/${namespaceFilter}/`) || !r.path.includes("/namespaces/") && namespaceFilter === this.orchestrator.config.defaultNamespace : true
+    ) : await this.orchestrator.searchAcrossNamespaces({
+      query,
+      namespaces: namespaceFilter ? [namespaceFilter] : void 0,
+      maxResults,
+      mode: "search"
+    });
+    return {
+      query,
+      results: results.map((r) => ({
+        path: r.path,
+        score: r.score,
+        snippet: (r.snippet ?? "").slice(0, 800)
+      })),
+      count: results.length
+    };
+  }
+  async memoryProfile(namespace, principal) {
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const profile = await storage.readProfile();
+    return {
+      profile: profile || "No profile built yet. The profile builds automatically through conversations."
+    };
+  }
+  async memoryEntitiesList(namespace, principal) {
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const entities = await storage.readEntities();
+    return { entities, count: entities.length };
+  }
+  async memoryQuestions(namespace, principal) {
+    const resolvedNs = this.resolveReadableNamespace(namespace, principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const questions = await storage.readQuestions();
+    return {
+      questions: questions.map((q) => ({ id: q.id, question: q.question, resolved: q.resolved })),
+      count: questions.length
+    };
+  }
+  async lastRecallSnapshot(sessionKey) {
+    const snapshot = sessionKey ? this.orchestrator.lastRecall.get(sessionKey) : this.orchestrator.lastRecall.getMostRecent();
+    return snapshot ?? { message: "No recall snapshot available" };
+  }
+  async intentDebug(namespace) {
+    const snapshot = await this.orchestrator.getLastIntentSnapshot(namespace);
+    return snapshot ?? { message: "No intent debug snapshot available" };
+  }
+  async qmdDebug(namespace) {
+    const snapshot = await this.orchestrator.getLastQmdRecallSnapshot(namespace);
+    return snapshot ?? { message: "No QMD debug snapshot available" };
+  }
+  async graphExplainLastRecall(namespace) {
+    const explanation = await this.orchestrator.explainLastGraphRecall({ namespace });
+    return { explanation };
+  }
+  async memoryFeedback(request) {
+    if (!this.orchestrator.config.feedbackEnabled) {
+      return {
+        recorded: false,
+        enabled: false,
+        reason: "Feedback is disabled. Enable `feedbackEnabled: true` in the Engram config to store feedback."
+      };
+    }
+    await this.orchestrator.recordMemoryFeedback(
+      request.memoryId,
+      request.vote,
+      request.note
+    );
+    return { recorded: true };
+  }
+  async memoryPromote(request) {
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    await storage.updateMemoryFrontmatter(request.memoryId, {
+      lifecycleState: "active",
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { promoted: true, memoryId: request.memoryId };
+  }
+  async contextCheckpoint(request) {
+    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const storage = await this.orchestrator.getStorage(resolvedNs);
+    const storageDir = storage.dir;
+    const { writeFile: writeFile31, mkdir: mkdir32 } = await import("fs/promises");
+    const { join: join5, resolve } = await import("path");
+    const safeKey = request.sessionKey.replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!safeKey) throw new EngramAccessInputError("sessionKey is required");
+    const checkpointDir = join5(storageDir, "checkpoints", safeKey);
+    const resolved = resolve(checkpointDir);
+    if (!resolved.startsWith(resolve(storageDir))) {
+      throw new EngramAccessInputError("Invalid sessionKey");
+    }
+    await mkdir32(checkpointDir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const filePath = join5(checkpointDir, `checkpoint-${ts}.md`);
+    await writeFile31(filePath, request.context, "utf-8");
+    return { saved: true };
+  }
   async lcmStatus() {
     if (!this.orchestrator.lcmEngine || !this.orchestrator.lcmEngine.enabled) {
       return {
@@ -32535,4 +32640,4 @@ export {
   EngramAccessInputError,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-RITRBWEK.js.map
+//# sourceMappingURL=chunk-JH4LLA7O.js.map