@joshuaswarren/openclaw-engram 8.3.64 → 8.3.66

package/dist/index.js

@@ -1604,6 +1604,21 @@ var FallbackLlmClient = class {
 
 // src/schemas.ts
 import { z } from "zod";
+var MemoryActionTypeSchema = z.enum([
+  "store_episode",
+  "store_note",
+  "update_note",
+  "create_artifact",
+  "summarize_node",
+  "discard",
+  "link_graph"
+]);
+var MemoryActionEligibilityContextSchema = z.object({
+  confidence: z.number().min(0).max(1),
+  lifecycleState: z.enum(["active", "validated", "candidate", "stale", "archived"]),
+  importance: z.number().min(0).max(1),
+  source: z.enum(["extraction", "consolidation", "replay", "manual", "unknown"])
+}).strict();
 var ExtractedFactSchema = z.object({
   category: z.enum(["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill"]),
   content: z.string().describe("The memory content \u2014 a clear, standalone statement"),
@@ -10919,6 +10934,92 @@ async function readAllEdges(memoryDir, config) {
   ]);
   return parts.flat();
 }
+function isValidGraphEdge(raw, expectedType) {
+  if (!raw || typeof raw !== "object") return false;
+  const edge = raw;
+  return edge.type === expectedType && typeof edge.from === "string" && edge.from.length > 0 && typeof edge.to === "string" && edge.to.length > 0 && typeof edge.weight === "number" && Number.isFinite(edge.weight) && typeof edge.label === "string" && typeof edge.ts === "string";
+}
+async function analyzeGraphHealth(memoryDir, options) {
+  const enabledTypes = [];
+  if (options?.entityGraphEnabled !== false) enabledTypes.push("entity");
+  if (options?.timeGraphEnabled !== false) enabledTypes.push("time");
+  if (options?.causalGraphEnabled !== false) enabledTypes.push("causal");
+  const files = [];
+  const globalNodes = /* @__PURE__ */ new Set();
+  for (const type of enabledTypes) {
+    const filePath = graphFilePath(memoryDir, type);
+    let exists3 = true;
+    let totalLines = 0;
+    let validEdges = 0;
+    let corruptLines = 0;
+    const nodes = /* @__PURE__ */ new Set();
+    try {
+      const raw = await readFile14(filePath, "utf8");
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        totalLines += 1;
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (!isValidGraphEdge(parsed, type)) {
+            corruptLines += 1;
+            continue;
+          }
+          validEdges += 1;
+          nodes.add(parsed.from);
+          nodes.add(parsed.to);
+          globalNodes.add(parsed.from);
+          globalNodes.add(parsed.to);
+        } catch {
+          corruptLines += 1;
+        }
+      }
+    } catch {
+      exists3 = false;
+    }
+    files.push({
+      type,
+      filePath,
+      exists: exists3,
+      totalLines,
+      validEdges,
+      corruptLines,
+      uniqueNodes: nodes.size
+    });
+  }
+  const totals = files.reduce(
+    (acc, item) => {
+      acc.totalLines += item.totalLines;
+      acc.validEdges += item.validEdges;
+      acc.corruptLines += item.corruptLines;
+      return acc;
+    },
+    {
+      totalLines: 0,
+      validEdges: 0,
+      corruptLines: 0,
+      uniqueNodes: globalNodes.size
+    }
+  );
+  totals.uniqueNodes = globalNodes.size;
+  const report = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    enabledTypes,
+    totals,
+    files
+  };
+  if (options?.includeRepairGuidance === true) {
+    const guidance = [];
+    if (totals.corruptLines > 0) {
+      guidance.push("Corrupt graph lines detected: back up memory/state/graphs, then rebuild graphs from clean memory replay/extraction runs.");
+    }
+    if (totals.validEdges === 0) {
+      guidance.push("No valid edges detected yet: run normal extraction traffic (or replay ingestion) to seed graph files.");
+    }
+    if (guidance.length > 0) report.repairGuidance = guidance;
+  }
+  return report;
+}
 function detectCausalPhrase(text) {
   const lower = text.toLowerCase();
   for (const phrase of CAUSAL_PHRASES) {
@@ -20823,6 +20924,14 @@ async function runMigrateObservationsCliCommand(options) {
 async function runConversationIndexHealthCliCommand(orchestrator) {
   return orchestrator.getConversationIndexHealth();
 }
+async function runGraphHealthCliCommand(options) {
+  return analyzeGraphHealth(options.memoryDir, {
+    entityGraphEnabled: options.entityGraphEnabled,
+    timeGraphEnabled: options.timeGraphEnabled,
+    causalGraphEnabled: options.causalGraphEnabled,
+    includeRepairGuidance: options.includeRepairGuidance
+  });
+}
 async function runTailscaleStatusCliCommand(options = {}) {
   const helper = options.helper ?? new TailscaleHelper({ timeoutMs: options.timeoutMs });
   return helper.status();
@@ -21454,6 +21563,18 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(health, null, 2));
         console.log("OK");
       });
+      cmd.command("graph-health").description("Show graph edge-file integrity, node coverage, and corruption counts").option("--repair-guidance", "Include non-destructive repair guidance").action(async (...args) => {
+        const options = args[0] ?? {};
+        const report = await runGraphHealthCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          entityGraphEnabled: orchestrator.config.entityGraphEnabled,
+          timeGraphEnabled: orchestrator.config.timeGraphEnabled,
+          causalGraphEnabled: orchestrator.config.causalGraphEnabled,
+          includeRepairGuidance: options.repairGuidance === true
+        });
+        console.log(JSON.stringify(report, null, 2));
+        console.log("OK");
+      });
       cmd.command("tailscale-status").description("Show Tailscale availability and daemon status").option("--timeout-ms <n>", "Command timeout in milliseconds", "10000").action(async (...args) => {
         const options = args[0] ?? {};
         const timeoutMsRaw = parseInt(String(options.timeoutMs ?? "10000"), 10);