omp-fabric 1.3.4 → 1.4.0

package/dist/chunks/{chunk-2WDZT27Q.js → chunk-3H5LZWAG.js}

@@ -27,6 +27,9 @@ import {
   expandSessionEntriesChecked,
   normalizeSession
 } from "./chunk-6QBPSZJ5.js";
+import {
+  hashLcmPayload
+} from "./chunk-IY3IQPRQ.js";
 
 // src/providers/memory-provider.ts
 import fs from "node:fs";
@@ -59,10 +62,10 @@ var snippetAnchor = (text, query, queryMode) => {
     return Math.max(0, normalized.indexOf(phrase));
   }
   if (queryMode === "literal") {
-    const terms = [...new Set(tokenizeLexical(query))].sort(
+    const terms2 = [...new Set(tokenizeLexical(query))].sort(
       (left, right) => right.length - left.length || left.localeCompare(right)
     );
-    for (const term of terms) {
+    for (const term of terms2) {
       const index = normalized.indexOf(term);
       if (index >= 0) return index;
     }
@@ -226,6 +229,235 @@ var presentRecall = (input) => {
   return response;
 };
 
+// src/memory/lcm-adapter.ts
+var terms = (text) => [
+  ...new Set(text.normalize("NFKC").toLowerCase().match(/[\p{L}\p{N}_]+/gu) ?? [])
+];
+var score = (text, query) => {
+  if (!query?.trim()) return 0;
+  const available = new Set(terms(text));
+  return terms(query).reduce((total, term) => total + (available.has(term) ? 1 : 0), 0);
+};
+var excerpt = (text, max = 480) => ({
+  snippet: text.length <= max ? text : text.slice(0, max),
+  truncated: text.length > max
+});
+var sourceKey = (sessionId, entryId, revision) => `${sessionId}:${entryId}:${revision}`;
+var activeBinding = (options, sessionId) => options.branchForSession?.(sessionId);
+var activeSourceSet = (binding) => binding?.activeSourceKeys === void 0 ? void 0 : new Set(binding.activeSourceKeys);
+var sessionScope = (args, currentSessionId) => {
+  const scope = typeof args.scope === "string" && args.scope.startsWith("session:") ? args.scope.slice("session:".length) : void 0;
+  return scope ?? currentSessionId;
+};
+var activeAllowed = (branches, binding, key) => {
+  if (branches === "all") return { allowed: true };
+  if (!binding) return { allowed: false, reason: "active_branch_unbound" };
+  if (!binding.ready) return { allowed: false, reason: "session_incomplete" };
+  if (binding.activeSourceKeys !== void 0 && !activeSourceSet(binding)?.has(key)) {
+    return { allowed: false, reason: "source_off_active_branch" };
+  }
+  return { allowed: true };
+};
+var LcmMemoryAdapter = class {
+  constructor(options) {
+    this.options = options;
+    this.projectKey = options.projectKey ?? options.ledger.projectKey;
+    this.maxRaw = Math.max(1, Math.min(options.maxRawEntries ?? 1e3, 1e4));
+    this.maxSummary = Math.max(1, Math.min(options.maxSummaryNodes ?? 1e3, 1e4));
+  }
+  projectKey;
+  maxRaw;
+  maxSummary;
+  recall(args) {
+    const query = typeof args.query === "string" ? args.query : void 0;
+    const branches = args.branches === "all" ? "all" : "active";
+    const offset = typeof args.offset === "number" && args.offset >= 0 ? Math.floor(args.offset) : 0;
+    const pageSize = typeof args.pageSize === "number" && args.pageSize >= 1 ? Math.min(50, Math.floor(args.pageSize)) : 10;
+    const selectedSession = sessionScope(args, this.options.currentSessionId);
+    const reasons = /* @__PURE__ */ new Set();
+    const raw = selectedSession === void 0 ? this.options.ledger.readRawPage(void 0, 0, this.maxRaw + 1) : this.options.ledger.readRawPage(selectedSession, 0, this.maxRaw + 1);
+    const rawBounded = raw.slice(0, this.maxRaw);
+    const summaryBranch = branches === "active" && selectedSession !== void 0 ? activeBinding(this.options, selectedSession)?.branch : void 0;
+    const summaries = selectedSession === void 0 ? this.options.summaries.listNodes({ limit: this.maxSummary + 1 }) : this.options.summaries.listNodes({ sessionId: selectedSession, limit: this.maxSummary + 1, ...summaryBranch === void 0 ? {} : { branch: summaryBranch } });
+    const summaryBounded = summaries.slice(0, this.maxSummary);
+    if (raw.length > this.maxRaw) reasons.add("raw_entry_limit");
+    if (summaries.length > this.maxSummary) reasons.add("summary_node_limit");
+    const hits = [];
+    for (const entry of rawBounded) {
+      const binding = activeBinding(this.options, entry.sessionId);
+      const allowed = activeAllowed(branches, binding, sourceKey(entry.sessionId, entry.entryId, entry.revision));
+      if (!allowed.allowed) {
+        if (allowed.reason) reasons.add(allowed.reason);
+        continue;
+      }
+      const value = score(entry.content, query);
+      if (query && value === 0) continue;
+      const preview = excerpt(entry.content);
+      hits.push({
+        kind: "lcm.raw",
+        sessionId: entry.sessionId,
+        score: value,
+        snippet: preview.snippet,
+        truncated: preview.truncated,
+        source: {
+          kind: "raw",
+          projectKey: entry.projectKey,
+          sessionId: entry.sessionId,
+          entryId: entry.entryId,
+          revision: entry.revision,
+          contentHash: entry.payloadHash,
+          sourceHash: entry.payloadHash
+        },
+        follow: {
+          ref: "memory.expand",
+          args: {
+            session: `lcm.raw:${entry.sessionId}:${entry.entryId}:${entry.revision}`,
+            branches,
+            expectedSourceHash: entry.payloadHash
+          }
+        }
+      });
+    }
+    for (const node of summaryBounded) {
+      if (node.state !== "ready") {
+        reasons.add(`summary_${node.state}`);
+        continue;
+      }
+      const binding = activeBinding(this.options, node.sessionId);
+      if (branches === "active") {
+        if (!binding) {
+          reasons.add("active_branch_unbound");
+          continue;
+        }
+        if (!binding.ready) {
+          reasons.add("session_incomplete");
+          continue;
+        }
+        const active = activeSourceSet(binding);
+        if (active && node.sources.some((source) => !active.has(sourceKey(node.sessionId, source.entryId, source.revision)))) {
+          reasons.add("summary_off_active_branch");
+          continue;
+        }
+      }
+      const value = score(node.text, query);
+      if (query && value === 0) continue;
+      const preview = excerpt(node.text);
+      hits.push({
+        kind: "lcm.summary",
+        sessionId: node.sessionId,
+        score: value,
+        snippet: preview.snippet,
+        truncated: preview.truncated,
+        source: {
+          kind: "summary",
+          projectKey: node.projectKey,
+          sessionId: node.sessionId,
+          nodeId: node.nodeId,
+          sourceHash: node.sourceHash
+        },
+        follow: {
+          ref: "memory.expand",
+          args: { session: `lcm.summary:${node.nodeId}`, branches, expectedSourceHash: node.sourceHash }
+        }
+      });
+    }
+    hits.sort((left, right) => right.score - left.score || left.sessionId.localeCompare(right.sessionId) || left.source.kind.localeCompare(right.source.kind) || String(left.source.entryId ?? left.source.nodeId).localeCompare(String(right.source.entryId ?? right.source.nodeId)));
+    const page = hits.slice(offset, offset + pageSize);
+    return {
+      total: hits.length,
+      hits: page,
+      next: offset + page.length < hits.length ? { ref: "memory.recall", args: { ...args, offset: offset + page.length } } : null,
+      coverage: {
+        complete: reasons.size === 0,
+        indexedSessions: new Set(hits.map((hit) => hit.sessionId)).size,
+        eligibleSessions: new Set(hits.map((hit) => hit.sessionId)).size,
+        staleSessions: 0,
+        incompleteSessions: reasons.size === 0 ? 0 : 1,
+        reasons: [...reasons].sort()
+      }
+    };
+  }
+  expand(args) {
+    const address = typeof args.session === "string" ? args.session : "";
+    const branches = args.branches === "all" ? "all" : "active";
+    if (address.startsWith("lcm.summary:")) {
+      const node = this.options.summaries.getNode(address.slice("lcm.summary:".length));
+      if (!node) return { entries: [], next: null, error: { code: "stale_pointer", message: "summary node is unavailable" } };
+      if (node.state !== "ready") return { entries: [], next: null, error: { code: "incomplete_coverage", message: `summary node is ${node.state}` } };
+      const binding2 = activeBinding(this.options, node.sessionId);
+      if (branches === "active") {
+        if (!binding2 || !binding2.ready) return { entries: [], next: null, error: { code: "incomplete_coverage", message: "summary lineage is not ready" } };
+        const active = activeSourceSet(binding2);
+        if (active && node.sources.some((source) => !active.has(sourceKey(node.sessionId, source.entryId, source.revision)))) {
+          return { entries: [], next: null, error: { code: "stale_pointer", message: "summary is outside the active branch" } };
+        }
+      }
+      const expected2 = typeof args.expectedSourceHash === "string" ? args.expectedSourceHash : void 0;
+      if (expected2 && expected2 !== node.sourceHash) return { entries: [], next: null, error: { code: "stale_pointer", message: "summary source hash changed", expectedSourceHash: expected2, actualSourceHash: node.sourceHash } };
+      return {
+        session: address,
+        sourceHash: node.sourceHash,
+        branches,
+        lineageFingerprint: node.lineageFingerprint ?? null,
+        entryCount: 1,
+        entries: [{
+          index: 0,
+          entryId: node.nodeId,
+          parentId: null,
+          type: "summary",
+          role: "compactionSummary",
+          timestamp: node.createdAt,
+          isError: false,
+          text: node.text,
+          textRange: { start: 0, end: node.text.length, total: node.text.length, complete: true },
+          anchor: true,
+          structuredContent: { nodeId: node.nodeId, sourceHash: node.sourceHash, children: node.children, sources: node.sources }
+        }],
+        next: null
+      };
+    }
+    const parts = address.split(":");
+    if (parts.length < 4 || parts[0] !== "lcm.raw") return { entries: [], next: null, error: { code: "invalid_address", message: "invalid LCM raw address" } };
+    const revision = Number(parts.at(-1));
+    const entryId = parts.slice(2, -1).join(":");
+    const sessionId = parts[1];
+    if (!sessionId || !entryId || !Number.isSafeInteger(revision) || revision < 1) return { entries: [], next: null, error: { code: "invalid_address", message: "invalid LCM raw address" } };
+    const entry = this.options.ledger.readRawEntry(sessionId, entryId, revision);
+    if (!entry) return { entries: [], next: null, error: { code: "stale_pointer", message: "raw source is unavailable" } };
+    const binding = activeBinding(this.options, sessionId);
+    const allowed = activeAllowed(branches, binding, sourceKey(sessionId, entryId, revision));
+    if (!allowed.allowed) return { entries: [], next: null, error: { code: allowed.reason === "source_off_active_branch" ? "stale_pointer" : "incomplete_coverage", message: allowed.reason ?? "raw lineage is unavailable" } };
+    const payload = JSON.parse(entry.payloadJson);
+    const sourceHash = hashLcmPayload(payload);
+    const expected = typeof args.expectedSourceHash === "string" ? args.expectedSourceHash : void 0;
+    if (expected && expected !== sourceHash) return { entries: [], next: null, error: { code: "stale_pointer", message: "raw source hash changed", expectedSourceHash: expected, actualSourceHash: sourceHash } };
+    const max = typeof args.maxChars === "number" ? Math.min(24e3, Math.max(256, Math.floor(args.maxChars))) : 2e4;
+    const start = typeof args.textOffset === "number" ? Math.max(0, Math.floor(args.textOffset)) : 0;
+    const text = entry.content.slice(start, start + max);
+    const complete = start + text.length >= entry.content.length;
+    return {
+      session: address,
+      sourceHash,
+      branches,
+      entryCount: 1,
+      entries: [{
+        index: 0,
+        entryId: entry.entryId,
+        parentId: entry.parentEntryId,
+        type: "raw",
+        role: entry.role,
+        timestamp: entry.createdAt,
+        isError: false,
+        text,
+        textRange: { start, end: start + text.length, total: entry.content.length, complete },
+        anchor: true,
+        structuredContent: payload
+      }],
+      next: complete ? null : { ref: "memory.expand", args: { ...args, textOffset: start + text.length } }
+    };
+  }
+};
+
 // src/providers/arg-normalization.ts
 var normalizeForm = (key) => key.toLowerCase().replace(/[^a-z0-9]/g, "");
 var KEY_SYNONYM_CLASSES = [
@@ -627,6 +859,19 @@ var recallSessionOutputSchema = {
     "follow"
   ]
 };
+var lcmRecallOutputSchema = {
+  type: "object",
+  properties: {
+    kind: { type: "string", enum: ["lcm.raw", "lcm.summary"] },
+    sessionId: { type: "string" },
+    score: { type: "number" },
+    snippet: { type: "string" },
+    truncated: { type: "boolean" },
+    source: { type: "object" },
+    follow: callOutputSchema("memory.expand")
+  },
+  required: ["kind", "sessionId", "score", "snippet", "truncated", "source", "follow"]
+};
 var recallOutputSchema = {
   type: "object",
   description: "Bounded ranked memory hits with uniform follow and pagination calls.",
@@ -635,7 +880,7 @@ var recallOutputSchema = {
     hits: {
       type: "array",
       description: "Call tools.call(hit.follow) to expand an entry or resolve a cold session.",
-      items: { oneOf: [recallEntryOutputSchema, recallSessionOutputSchema] }
+      items: { oneOf: [recallEntryOutputSchema, recallSessionOutputSchema, lcmRecallOutputSchema] }
     },
     next: {
       oneOf: [callOutputSchema("memory.recall"), { type: "null" }],
@@ -1137,6 +1382,10 @@ var MemoryProvider = class {
   }
   async invoke(actionName, args, invocationContext) {
     try {
+      if (this.context.lcm && (actionName === "recall" || actionName === "expand")) {
+        const adapter = new LcmMemoryAdapter(this.context.lcm);
+        return actionName === "recall" ? adapter.recall(args) : adapter.expand(args);
+      }
       switch (actionName) {
         case "recall":
           return await this.recall(args, invocationContext);
@@ -1883,4 +2132,4 @@ export {
   normalizeMemoryArgs,
   MemoryProvider
 };
-//# sourceMappingURL=chunk-2WDZT27Q.js.map
+//# sourceMappingURL=chunk-3H5LZWAG.js.map