@remnic/core 9.69.55 → 9.69.57

package/dist/chunk-RMF763SX.js

@@ -0,0 +1,115 @@
+import {
+  applyExtractionSourceGrounding
+} from "./chunk-YRH3C2OJ.js";
+import {
+  CONNECTOR_LABEL_MAX_LENGTH,
+  knownConnectorIds
+} from "./chunk-BQB5ZMYO.js";
+import {
+  isValidConnectorId
+} from "./chunk-GK6NOQE6.js";
+import {
+  deriveSourceConnector
+} from "./chunk-FF2XYADH.js";
+import {
+  resolvePipelineProcessingCapabilities
+} from "./chunk-JUOZ62Y7.js";
+
+// src/source-agent-qualifier.ts
+function resolveSourceConnector(turns) {
+  const contributing = turns.filter((turn) => turn.extractionContextOnly !== true);
+  const derived = deriveSourceConnector(contributing);
+  if (derived === void 0 || !isValidConnectorId(derived)) return void 0;
+  return /[\u0000-\u001F\u007F]/.test(derived) ? void 0 : derived;
+}
+function headerConnector(connector) {
+  return connector !== void 0 && connector.length <= CONNECTOR_LABEL_MAX_LENGTH ? connector : void 0;
+}
+function renderExtractionConversation(boundedTurns, sourceConnector) {
+  const renderedConversation = boundedTurns.map((t) => `[${t.extractionContextOnly === true ? `context ${t.role}` : t.role}] ${t.content}`).join("\n\n");
+  const conversation = sourceConnector === void 0 ? renderedConversation : `Source agent: ${sourceConnector}
+
+Tool and command instructions in this conversation apply to the ${sourceConnector} agent unless they are clearly universal.
+
+${renderedConversation}`;
+  return { conversation, renderedConversation };
+}
+function applyGroundingWithConnector(config, result, ctx) {
+  const caps = resolvePipelineProcessingCapabilities(config);
+  const options = {
+    sourceGrounding: caps.sourceGrounding,
+    anchorTemporalExpressions: caps.delinearize,
+    spanMode: config.extraction?.spanMode ?? "off"
+  };
+  const known = buildKnownConnectors(ctx.sourceConnector);
+  const scoped = ctx.scopeClassificationEnabled === false ? result : forceProjectScopeOnAnyQualifier(result, known);
+  if (ctx.sourceConnector === void 0) {
+    return applyExtractionSourceGrounding(scoped, ctx.groundingSource, ctx.assertionSource, ctx.roleAssertionSources, ctx.messageTimestamp, options);
+  }
+  const prepared = prepareTrustedConnectorQualifier(scoped, ctx.sourceConnector, known);
+  const grounded = applyExtractionSourceGrounding(prepared.result, ctx.groundingSource, ctx.assertionSource, ctx.roleAssertionSources, ctx.messageTimestamp, options);
+  return restoreTrustedConnectorQualifier(grounded);
+}
+function buildKnownConnectors(trusted) {
+  const known = /* @__PURE__ */ new Set();
+  for (const id of knownConnectorIds()) known.add(id.toLowerCase());
+  if (trusted !== void 0) known.add(trusted.toLowerCase());
+  return known;
+}
+function parseLeadingQualifier(content, known) {
+  const lower = content.toLowerCase();
+  for (const lead of ["in ", "for "]) {
+    if (!lower.startsWith(lead)) continue;
+    const m = lower.slice(lead.length).match(/^([a-z0-9][a-z0-9._-]*)\s*,/u);
+    if (m && known.has(m[1])) {
+      const consumed = lead.length + m[0].length;
+      return { agent: m[1], rest: content.slice(consumed).replace(/^[\s,.;:]+/u, "") };
+    }
+  }
+  const pm = lower.match(/^([a-z0-9][a-z0-9._-]*)'s(?![\p{L}\p{N}])/u);
+  if (pm && known.has(pm[1])) {
+    return { agent: pm[1], rest: content.slice(pm[0].length).replace(/^[\s,.;:]+/u, "") };
+  }
+  return void 0;
+}
+function forceProjectScopeOnAnyQualifier(result, known) {
+  let any = false;
+  const facts = result.facts.map((fact) => {
+    if (fact.scope === "project") return fact;
+    if (parseLeadingQualifier(fact.content, known) === void 0) return fact;
+    any = true;
+    return { ...fact, scope: "project" };
+  });
+  return any ? { ...result, facts } : result;
+}
+var RESTORE_KEY = "_qo";
+function prepareTrustedConnectorQualifier(result, trustedConnector, known) {
+  const trusted = trustedConnector.toLowerCase();
+  const facts = result.facts.map((fact) => {
+    const parsed = parseLeadingQualifier(fact.content, known);
+    if (parsed === void 0 || parsed.agent !== trusted) return fact;
+    return { ...fact, content: parsed.rest, [RESTORE_KEY]: fact.content };
+  });
+  return { result: { ...result, facts } };
+}
+function restoreTrustedConnectorQualifier(grounded) {
+  let touched = false;
+  const facts = grounded.facts.map((fact) => {
+    const record = fact;
+    const original = record[RESTORE_KEY];
+    if (typeof original !== "string") return fact;
+    touched = true;
+    const rest = { ...record };
+    delete rest[RESTORE_KEY];
+    return { ...rest, content: original };
+  });
+  return touched ? { ...grounded, facts } : grounded;
+}
+
+export {
+  resolveSourceConnector,
+  headerConnector,
+  renderExtractionConversation,
+  applyGroundingWithConnector
+};
+//# sourceMappingURL=chunk-RMF763SX.js.map

package/dist/chunk-RN6ZCNM5.js

@@ -0,0 +1,321 @@
+import {
+  resolveCueAnchorStoreDir,
+  validateCueAnchor
+} from "./chunk-BMWN7B3Y.js";
+import {
+  isValidityExpiredNow
+} from "./chunk-6CIAGZ6X.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-YCVB7X56.js";
+import {
+  inferMemoryStatus,
+  toMemoryPathRel
+} from "./chunk-7RJUVTVF.js";
+import {
+  isSupportPassportPrivateMemory
+} from "./chunk-PWPIERBM.js";
+import {
+  stripAttributesSuffix
+} from "./chunk-JDSVLVCG.js";
+import {
+  throwIfAborted
+} from "./chunk-BTTPKDIL.js";
+import {
+  HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY,
+  resolveAbstractionNodeStoreDir,
+  validateAbstractionNode
+} from "./chunk-46EST7JO.js";
+import {
+  compareDeterministicStrings
+} from "./chunk-G73MCJKL.js";
+import {
+  isRecord
+} from "./chunk-A2IYSXDQ.js";
+import {
+  listJsonFilesStrict,
+  readJsonFile
+} from "./chunk-B6O2YLUR.js";
+
+// src/harmonic-retrieval.ts
+import path from "path";
+async function readSourceMemories(options) {
+  const sourceMemories = /* @__PURE__ */ new Map();
+  try {
+    const { StorageManager } = await import("./storage.js");
+    const storage = new StorageManager(options.memoryDir);
+    const [hotMemories, coldMemories] = await Promise.all([
+      storage.readAllMemories({ abortSignal: options.abortSignal }),
+      storage.readAllColdMemories()
+    ]);
+    for (const memory of [...hotMemories, ...coldMemories]) {
+      throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+      sourceMemories.set(memory.frontmatter.id, memory);
+    }
+  } catch {
+    throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+    sourceMemories.clear();
+  }
+  return sourceMemories;
+}
+function parseSourceMemoryInsertedAt(node) {
+  const insertedAtById = /* @__PURE__ */ new Map();
+  const insertedAtRaw = node.metadata?.[HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY];
+  if (!insertedAtRaw) return insertedAtById;
+  try {
+    const parsed = JSON.parse(insertedAtRaw);
+    if (!isRecord(parsed)) return insertedAtById;
+    for (const [memoryId, value] of Object.entries(parsed)) {
+      if (typeof value === "string") insertedAtById.set(memoryId, value);
+    }
+  } catch {
+  }
+  return insertedAtById;
+}
+function projectSourceBackedNode(node, sourceMemories, memoryDir, temporalExpiredInInjection, nowMs) {
+  const sourceMemoryIds = node.sourceMemoryIds ?? [];
+  if (sourceMemoryIds.length === 0) return node;
+  const activeSourceMemoryIds = sourceMemoryIds.filter((memoryId) => {
+    const memory = sourceMemories.get(memoryId);
+    return memory !== void 0 && // #2332: a private support-passport record leaves the eligible set the
+    // same way a rejected one does — a node title or anchor attribution
+    // rebuilt from it would leak governed metadata into the deep-recall
+    // frontier (and every other graph reader) before any content check runs.
+    !isSupportPassportPrivateMemory(memory) && inferMemoryStatus(memory.frontmatter, toMemoryPathRel(memoryDir, memory.path)) === "active" && (temporalExpiredInInjection || !isValidityExpiredNow(memory.frontmatter, nowMs));
+  });
+  if (activeSourceMemoryIds.length === 0) return null;
+  const insertedAtById = parseSourceMemoryInsertedAt(node);
+  const insertedAtMs = (memoryId) => {
+    const parsedMs = Date.parse(insertedAtById.get(memoryId) ?? "");
+    return Number.isFinite(parsedMs) ? parsedMs : Date.parse(node.recordedAt);
+  };
+  activeSourceMemoryIds.sort(
+    (left, right) => insertedAtMs(right) - insertedAtMs(left) || compareDeterministicStrings(left, right)
+  );
+  const activeMemories = activeSourceMemoryIds.flatMap((memoryId) => {
+    const memory = sourceMemories.get(memoryId);
+    return memory ? [memory] : [];
+  });
+  const activeContents = activeMemories.map(
+    (memory) => memory.frontmatter.structuredAttributes ? stripAttributesSuffix(memory.content) : memory.content
+  );
+  let metadata;
+  const activeInsertedAt = activeSourceMemoryIds.flatMap((memoryId) => {
+    const value = insertedAtById.get(memoryId);
+    return typeof value === "string" ? [[memoryId, value]] : [];
+  });
+  if (activeInsertedAt.length > 0) {
+    metadata = {
+      [HARMONIC_SOURCE_MEMORY_INSERTED_AT_KEY]: JSON.stringify(Object.fromEntries(activeInsertedAt))
+    };
+  }
+  return {
+    ...node,
+    sourceMemoryIds: activeSourceMemoryIds,
+    title: activeContents[0]?.slice(0, 80) ?? node.title,
+    summary: activeContents.slice(0, 3).join("; ").slice(0, 400),
+    tags: [...new Set(activeMemories.flatMap((memory) => memory.frontmatter.tags))].sort(compareDeterministicStrings),
+    entityRefs: [
+      ...new Set(
+        activeMemories.flatMap(
+          (memory) => typeof memory.frontmatter.entityRef === "string" ? [memory.frontmatter.entityRef] : []
+        )
+      )
+    ].sort(compareDeterministicStrings),
+    metadata
+  };
+}
+function anchorMatchesProjectedNode(anchor, nodeRef, node, allowLegacyAttribution) {
+  const activeSourceMemoryIds = node.sourceMemoryIds ?? [];
+  if (activeSourceMemoryIds.length === 0) return true;
+  if (!anchor.sourceMemoryIdsByNodeRef) return allowLegacyAttribution;
+  const anchorSourceMemoryIds = anchor.sourceMemoryIdsByNodeRef[nodeRef] ?? [];
+  return anchorSourceMemoryIds.some((sourceMemoryId) => activeSourceMemoryIds.includes(sourceMemoryId));
+}
+function scoreNode(node, queryTokens) {
+  const matchedFields = [];
+  let score = 0;
+  const titleMatches = countRecallTokenOverlap(queryTokens, node.title);
+  if (titleMatches > 0) {
+    score += titleMatches * 3;
+    matchedFields.push("title");
+  }
+  const summaryMatches = countRecallTokenOverlap(queryTokens, node.summary);
+  if (summaryMatches > 0) {
+    score += summaryMatches * 3;
+    matchedFields.push("summary");
+  }
+  const tagMatches = countRecallTokenOverlap(queryTokens, node.tags?.join(" "));
+  if (tagMatches > 0) {
+    score += tagMatches * 2;
+    matchedFields.push("tags");
+  }
+  const entityMatches = countRecallTokenOverlap(queryTokens, node.entityRefs?.join(" "));
+  if (entityMatches > 0) {
+    score += entityMatches * 2;
+    matchedFields.push("entityRefs");
+  }
+  const kindMatches = countRecallTokenOverlap(queryTokens, `${node.kind} ${node.abstractionLevel}`);
+  if (kindMatches > 0) {
+    score += kindMatches;
+    matchedFields.push("kind");
+  }
+  return { score, matchedFields };
+}
+function scoreAnchor(anchor, queryTokens, eligibleNodeTags) {
+  const matchedFields = [];
+  let score = 0;
+  const valueMatches = countRecallTokenOverlap(queryTokens, anchor.anchorValue);
+  const normalizedMatches = countRecallTokenOverlap(queryTokens, anchor.normalizedCue);
+  const cueMatches = Math.max(valueMatches, normalizedMatches);
+  if (cueMatches > 0) {
+    score += cueMatches * 4;
+    if (valueMatches > 0) matchedFields.push("anchorValue");
+    if (normalizedMatches > 0) matchedFields.push("anchor");
+  }
+  const typeMatches = countRecallTokenOverlap(queryTokens, anchor.anchorType);
+  if (typeMatches > 0) {
+    score += typeMatches;
+    matchedFields.push("anchorType");
+  }
+  const tagMatches = countRecallTokenOverlap(queryTokens, eligibleNodeTags.join(" "));
+  if (tagMatches > 0) {
+    score += tagMatches * 2;
+    matchedFields.push("anchorTags");
+  }
+  return { score, matchedFields };
+}
+async function readAbstractionNodes(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const files = await listJsonFilesStrict(path.join(rootDir, "nodes"), { allowMissingDirectory: true });
+  const nodes = [];
+  for (const filePath of files) {
+    try {
+      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));
+    } catch {
+    }
+  }
+  return nodes;
+}
+async function readCueAnchors(options) {
+  const abstractionRoot = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const rootDir = resolveCueAnchorStoreDir(abstractionRoot);
+  const files = await listJsonFilesStrict(rootDir, { allowMissingDirectory: true });
+  const anchors = [];
+  for (const filePath of files) {
+    try {
+      anchors.push(validateCueAnchor(await readJsonFile(filePath)));
+    } catch {
+    }
+  }
+  return anchors;
+}
+async function readProjectedHarmonicGraph(options) {
+  throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+  const nodes = await readAbstractionNodes(options);
+  const sourceBacked = nodes.some((node) => (node.sourceMemoryIds?.length ?? 0) > 0);
+  const sourceMemories = sourceBacked ? await readSourceMemories(options) : /* @__PURE__ */ new Map();
+  const nowMs = options.nowMs ?? Date.now();
+  const legacyCompatibleNodeRefs = /* @__PURE__ */ new Set();
+  const projectedNodes = nodes.flatMap((node) => {
+    const projected = projectSourceBackedNode(
+      node,
+      sourceMemories,
+      options.memoryDir,
+      options.temporalExpiredInInjection === true,
+      nowMs
+    );
+    if (projected && (node.sourceMemoryIds?.length ?? 0) > 0 && projected.sourceMemoryIds?.length === node.sourceMemoryIds?.length) {
+      legacyCompatibleNodeRefs.add(node.nodeId);
+    }
+    return projected ? [projected] : [];
+  });
+  if (!options.anchorsEnabled) return { nodes: projectedNodes, anchors: [] };
+  throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+  const nodeIndex = new Map(projectedNodes.map((node) => [node.nodeId, node]));
+  const anchors = (await readCueAnchors(options)).flatMap((anchor) => {
+    throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+    const nodeRefs = anchor.nodeRefs.filter((nodeRef) => {
+      const node = nodeIndex.get(nodeRef);
+      return node !== void 0 && anchorMatchesProjectedNode(anchor, nodeRef, node, legacyCompatibleNodeRefs.has(nodeRef));
+    });
+    return nodeRefs.length > 0 ? [{ ...anchor, nodeRefs }] : [];
+  });
+  return { nodes: projectedNodes, anchors };
+}
+async function searchHarmonicRetrieval(options) {
+  throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["what", "which"]));
+  if (queryTokens.size === 0 || options.maxResults <= 0) return [];
+  const { nodes: eligibleNodes, anchors } = await readProjectedHarmonicGraph(options);
+  const candidates = /* @__PURE__ */ new Map();
+  for (const node of eligibleNodes) {
+    throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+    const { score, matchedFields } = scoreNode(node, queryTokens);
+    if (score <= 0) continue;
+    candidates.set(node.nodeId, {
+      node,
+      nodeScore: score,
+      anchorScore: 0,
+      matchedFields: new Set(matchedFields),
+      matchedAnchors: /* @__PURE__ */ new Map()
+    });
+  }
+  if (options.anchorsEnabled) {
+    throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+    const nodeIndex = new Map(eligibleNodes.map((node) => [node.nodeId, node]));
+    for (const anchor of anchors) {
+      throwIfAborted(options.abortSignal, "harmonic retrieval aborted");
+      const eligibleNodeRefs = anchor.nodeRefs;
+      const eligibleNodeTags = new Set(eligibleNodeRefs.flatMap((nodeRef) => nodeIndex.get(nodeRef)?.tags ?? []));
+      const eligibleAnchorTags = anchor.tags?.filter((tag) => eligibleNodeTags.has(tag)) ?? [];
+      const { score, matchedFields } = scoreAnchor(anchor, queryTokens, eligibleAnchorTags);
+      if (score <= 0) continue;
+      for (const nodeRef of eligibleNodeRefs) {
+        const node = nodeIndex.get(nodeRef);
+        if (!node) continue;
+        const existing = candidates.get(nodeRef) ?? {
+          node,
+          nodeScore: 0,
+          anchorScore: 0,
+          matchedFields: /* @__PURE__ */ new Set(),
+          matchedAnchors: /* @__PURE__ */ new Map()
+        };
+        existing.anchorScore += score;
+        existing.matchedFields.add("anchor");
+        for (const field of matchedFields) existing.matchedFields.add(field);
+        existing.matchedAnchors.set(anchor.anchorId, {
+          anchorId: anchor.anchorId,
+          anchorType: anchor.anchorType,
+          anchorValue: anchor.anchorValue
+        });
+        candidates.set(nodeRef, existing);
+      }
+    }
+  }
+  return [...candidates.values()].map((candidate) => {
+    let score = candidate.nodeScore + candidate.anchorScore;
+    if (options.sessionKey && candidate.node.sessionKey === options.sessionKey) score += 0.5;
+    return {
+      node: candidate.node,
+      score,
+      nodeScore: candidate.nodeScore,
+      anchorScore: candidate.anchorScore,
+      matchedFields: [...candidate.matchedFields].sort(),
+      matchedAnchors: [...candidate.matchedAnchors.values()].sort(
+        (left, right) => left.anchorType.localeCompare(right.anchorType) || left.anchorValue.localeCompare(right.anchorValue)
+      )
+    };
+  }).filter((result) => result.nodeScore > 0 || result.anchorScore > 0).sort(
+    (left, right) => right.score - left.score || right.anchorScore - left.anchorScore || right.node.recordedAt.localeCompare(left.node.recordedAt)
+  ).slice(0, options.maxResults);
+}
+
+export {
+  readAbstractionNodes,
+  readCueAnchors,
+  readProjectedHarmonicGraph,
+  searchHarmonicRetrieval
+};
+//# sourceMappingURL=chunk-RN6ZCNM5.js.map