@plur-ai/core 0.7.7 → 0.8.2

package/dist/learn-async-VXBH3TYE.js

@@ -0,0 +1,184 @@
+import {
+  appendHistory,
+  buildDedupPrompt,
+  computeContentHash,
+  loadEngrams,
+  logger,
+  parseDedupResponse,
+  saveEngrams
+} from "./chunk-GRDNBUIJ.js";
+import {
+  withLock
+} from "./chunk-MY4XVDCE.js";
+import "./chunk-2ZDO52B4.js";
+
+// src/learn-async.ts
+function executeDedupDecision(deps, statement, context, decision, targetId, conflicts) {
+  switch (decision) {
+    case "NOOP": {
+      if (targetId) {
+        const existing = deps.getById(targetId);
+        if (existing) return { engram: existing, decision: "NOOP", existing_id: targetId };
+      }
+      return { engram: deps.learn(statement, context), decision: "ADD" };
+    }
+    case "UPDATE": {
+      if (targetId) {
+        const existing = deps.getById(targetId);
+        if (existing && existing.commitment !== "locked") {
+          return withLock(deps.engramsPath, () => {
+            const engrams = loadEngrams(deps.engramsPath);
+            const idx = engrams.findIndex((e) => e.id === targetId);
+            if (idx === -1) return { engram: deps.learn(statement, context), decision: "ADD" };
+            const updated = { ...engrams[idx] };
+            updated.statement = statement;
+            updated.content_hash = computeContentHash(statement);
+            updated.version = (updated.version ?? 1) + 1;
+            updated.activation.last_accessed = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+            if (context?.tags) updated.tags = [.../* @__PURE__ */ new Set([...updated.tags, ...context.tags])];
+            if (conflicts.length > 0) {
+              if (!updated.relations) updated.relations = { broader: [], narrower: [], related: [], conflicts: [] };
+              updated.relations.conflicts = [.../* @__PURE__ */ new Set([...updated.relations.conflicts ?? [], ...conflicts])];
+            }
+            engrams[idx] = updated;
+            saveEngrams(deps.engramsPath, engrams);
+            deps.syncIndex();
+            appendHistory(deps.rootPath, {
+              event: "engram_updated",
+              engram_id: targetId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              data: { old_statement: existing.statement, new_statement: statement, reason: "LLM dedup UPDATE" }
+            });
+            return {
+              engram: updated,
+              decision: "UPDATE",
+              existing_id: targetId,
+              tensions: conflicts.length > 0 ? conflicts : void 0
+            };
+          });
+        }
+      }
+      return { engram: deps.learn(statement, context), decision: "ADD" };
+    }
+    case "MERGE": {
+      if (targetId) {
+        const existing = deps.getById(targetId);
+        if (existing && existing.commitment !== "locked") {
+          return withLock(deps.engramsPath, () => {
+            const engrams = loadEngrams(deps.engramsPath);
+            const idx = engrams.findIndex((e) => e.id === targetId);
+            if (idx === -1) return { engram: deps.learn(statement, context), decision: "ADD" };
+            const merged = { ...engrams[idx] };
+            merged.statement = `${merged.statement} ${statement}`;
+            merged.content_hash = computeContentHash(merged.statement);
+            merged.version = (merged.version ?? 1) + 1;
+            merged.activation.last_accessed = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+            if (context?.tags) merged.tags = [.../* @__PURE__ */ new Set([...merged.tags, ...context.tags])];
+            if (0.7 > merged.activation.retrieval_strength) merged.activation.retrieval_strength = 0.7;
+            if (conflicts.length > 0) {
+              if (!merged.relations) merged.relations = { broader: [], narrower: [], related: [], conflicts: [] };
+              merged.relations.conflicts = [.../* @__PURE__ */ new Set([...merged.relations.conflicts ?? [], ...conflicts])];
+            }
+            engrams[idx] = merged;
+            saveEngrams(deps.engramsPath, engrams);
+            deps.syncIndex();
+            appendHistory(deps.rootPath, {
+              event: "engram_merged",
+              engram_id: targetId,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              data: { merged_statement: statement, reason: "LLM dedup MERGE" }
+            });
+            return {
+              engram: merged,
+              decision: "MERGE",
+              existing_id: targetId,
+              tensions: conflicts.length > 0 ? conflicts : void 0
+            };
+          });
+        }
+      }
+      return { engram: deps.learn(statement, context), decision: "ADD" };
+    }
+    case "ADD":
+    default: {
+      const engram = deps.learn(statement, context);
+      if (conflicts.length > 0) {
+        withLock(deps.engramsPath, () => {
+          const engrams = loadEngrams(deps.engramsPath);
+          const idx = engrams.findIndex((e) => e.id === engram.id);
+          if (idx !== -1) {
+            const updated = engrams[idx];
+            if (!updated.relations) updated.relations = { broader: [], narrower: [], related: [], conflicts: [] };
+            updated.relations.conflicts = [.../* @__PURE__ */ new Set([...updated.relations.conflicts ?? [], ...conflicts])];
+            engrams[idx] = updated;
+            saveEngrams(deps.engramsPath, engrams);
+            deps.syncIndex();
+          }
+        });
+      }
+      return { engram, decision: "ADD", tensions: conflicts.length > 0 ? conflicts : void 0 };
+    }
+  }
+}
+async function learnAsync(deps, statement, context) {
+  const hashMatch = deps.hashDedup(statement);
+  if (hashMatch) {
+    return { engram: hashMatch, decision: "NOOP", existing_id: hashMatch.id };
+  }
+  const { enabled = true, threshold = 0.85, mode = "llm" } = deps.dedupConfig;
+  if (!enabled || mode === "off") {
+    return { engram: deps.learn(statement, context), decision: "ADD" };
+  }
+  let candidates = [];
+  try {
+    candidates = await deps.recallHybrid(statement, { limit: 5 });
+  } catch {
+    candidates = deps.recall(statement, { limit: 5 });
+  }
+  candidates = candidates.filter((c) => c.status === "active");
+  if (candidates.length === 0) {
+    return { engram: deps.learn(statement, context), decision: "ADD" };
+  }
+  const llm = context?.llm;
+  let decision = "ADD";
+  let targetId = null;
+  let conflicts = [];
+  if (mode === "llm" && llm && deps.isLlmAvailable()) {
+    try {
+      const prompt = buildDedupPrompt(
+        statement,
+        candidates.map((c) => ({ id: c.id, statement: c.statement, type: c.type, domain: c.domain }))
+      );
+      const response = await llm(prompt);
+      const parsed = parseDedupResponse(response);
+      decision = parsed.decision;
+      targetId = parsed.target_id;
+      conflicts = parsed.conflicts;
+      deps.recordLlmSuccess();
+    } catch (err) {
+      logger.warning(`LLM dedup failed, falling back to cosine: ${err}`);
+      deps.recordLlmFailure();
+      decision = "ADD";
+    }
+  }
+  return executeDedupDecision(deps, statement, context, decision, targetId, conflicts);
+}
+async function learnBatch(deps, statements, llm) {
+  const results = [];
+  const stats = { added: 0, updated: 0, merged: 0, noops: 0 };
+  for (const { statement, context } of statements) {
+    const ctx = { ...context, llm: context?.llm ?? llm };
+    const result = await learnAsync(deps, statement, ctx);
+    results.push(result);
+    const key = result.decision.toLowerCase();
+    if (key === "noop") stats.noops++;
+    else if (key === "update") stats.updated++;
+    else if (key === "merge") stats.merged++;
+    else stats.added++;
+  }
+  return { results, stats };
+}
+export {
+  learnAsync,
+  learnBatch
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plur-ai/core",
-  "version": "0.7.7",
+  "version": "0.8.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",