recallnest 1.4.1 → 2.2.0

package/src/__tests__/confidence-metadata.test.ts

@@ -0,0 +1,125 @@
+/**
+ * F1: Memory Confidence Meta-tags — tests for structured confidence,
+ * source-based assignment, retrieval integration, and backward compat.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  assignDefaultConfidence,
+  getConfidence,
+  getConfidenceMetadata,
+  CONFIDENCE_DEFAULT,
+  type ConfidenceMetadata,
+} from "../confidence-tracker.js";
+import type { MemoryEntry } from "../store.js";
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makeEntry(metadataObj: Record<string, unknown>): MemoryEntry {
+  return {
+    id: "test-001",
+    text: "test",
+    vector: [],
+    category: "events",
+    scope: "test",
+    importance: 0.7,
+    timestamp: Date.now(),
+    metadata: JSON.stringify(metadataObj),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// assignDefaultConfidence
+// ---------------------------------------------------------------------------
+
+describe("F1: assignDefaultConfidence", () => {
+  test("manual source → direct reliability, score 0.9", () => {
+    const c = assignDefaultConfidence("manual");
+    expect(c.score).toBe(0.9);
+    expect(c.reliability).toBe("direct");
+  });
+
+  test("agent source → inferred reliability, score 0.7", () => {
+    const c = assignDefaultConfidence("agent");
+    expect(c.score).toBe(0.7);
+    expect(c.reliability).toBe("inferred");
+  });
+
+  test("conversation_import source → hearsay, score 0.5", () => {
+    const c = assignDefaultConfidence("conversation_import");
+    expect(c.score).toBe(0.5);
+    expect(c.reliability).toBe("hearsay");
+  });
+
+  test("session_distill source → inferred, score 0.6", () => {
+    const c = assignDefaultConfidence("session_distill");
+    expect(c.score).toBe(0.6);
+    expect(c.reliability).toBe("inferred");
+  });
+
+  test("explicit override takes precedence", () => {
+    const c = assignDefaultConfidence("agent", { score: 0.95, reliability: "direct" });
+    expect(c.score).toBe(0.95);
+    expect(c.reliability).toBe("direct");
+  });
+
+  test("explicit score only, reliability defaults to inferred", () => {
+    const c = assignDefaultConfidence("manual", { score: 0.3 });
+    expect(c.score).toBe(0.3);
+    expect(c.reliability).toBe("inferred");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getConfidence — backward compat
+// ---------------------------------------------------------------------------
+
+describe("F1: getConfidence backward compatibility", () => {
+  test("reads flat number confidence (legacy format)", () => {
+    const entry = makeEntry({ confidence: 0.42 });
+    expect(getConfidence(entry)).toBe(0.42);
+  });
+
+  test("reads structured confidence object", () => {
+    const entry = makeEntry({ confidence: { score: 0.88, reliability: "direct" } });
+    expect(getConfidence(entry)).toBe(0.88);
+  });
+
+  test("returns default when confidence missing", () => {
+    const entry = makeEntry({});
+    expect(getConfidence(entry)).toBe(CONFIDENCE_DEFAULT);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getConfidenceMetadata
+// ---------------------------------------------------------------------------
+
+describe("F1: getConfidenceMetadata", () => {
+  test("extracts structured ConfidenceMetadata", () => {
+    const entry = makeEntry({
+      confidence: { score: 0.75, reliability: "hearsay", verifiedAt: 1000, verifiedBy: "user" },
+    });
+    const meta = getConfidenceMetadata(entry);
+    expect(meta).not.toBeNull();
+    expect(meta!.score).toBe(0.75);
+    expect(meta!.reliability).toBe("hearsay");
+    expect(meta!.verifiedAt).toBe(1000);
+    expect(meta!.verifiedBy).toBe("user");
+  });
+
+  test("wraps legacy flat number into ConfidenceMetadata", () => {
+    const entry = makeEntry({ confidence: 0.55 });
+    const meta = getConfidenceMetadata(entry);
+    expect(meta).not.toBeNull();
+    expect(meta!.score).toBe(0.55);
+    expect(meta!.reliability).toBe("inferred");
+  });
+
+  test("returns null when confidence missing", () => {
+    const entry = makeEntry({});
+    expect(getConfidenceMetadata(entry)).toBeNull();
+  });
+});

package/src/__tests__/confidence-tracker.test.ts

@@ -4,6 +4,9 @@ import {
   confirmMemory,
   correctMemory,
   contradictMemory,
+  buildConfirmPatch,
+  buildCorrectPatch,
+  buildContradictPatch,
   getConfidence,
   applyConfidenceWeight,
   CONFIDENCE_DEFAULT,
@@ -178,6 +181,56 @@ describe("confidence-tracker", () => {
     });
   });
 
+  describe("patch builders (store-agnostic)", () => {
+    it("buildConfirmPatch returns metadata patch without touching store", () => {
+      const entry = makeEntry("e1", "test fact");
+      const patch = buildConfirmPatch(entry);
+      expect(patch).not.toBeNull();
+      expect(patch!.metadata.confidence).toBe(CONFIDENCE_CONFIRMED);
+      expect(patch!.update.entryId).toBe("e1");
+      expect(patch!.update.newConfidence).toBe(CONFIDENCE_CONFIRMED);
+      // Original entry metadata should NOT be mutated
+      expect(JSON.parse(entry.metadata!).confidence).toBeUndefined();
+    });
+
+    it("buildCorrectPatch includes correctedBy in history", () => {
+      const entry = makeEntry("e1", "old info");
+      const patch = buildCorrectPatch(entry, "new-id-123");
+      expect(patch).not.toBeNull();
+      expect(patch!.metadata.confidence).toBe(CONFIDENCE_CORRECTED);
+      expect(patch!.metadata.corrected_by).toBe("new-id-123");
+      const history = patch!.metadata.confidence_history as Array<{ correctedBy?: string }>;
+      expect(history[0].correctedBy).toBe("new-id-1"); // 8 chars
+    });
+
+    it("buildContradictPatch returns zero confidence", () => {
+      const entry = makeEntry("e1", "wrong");
+      const patch = buildContradictPatch(entry);
+      expect(patch!.metadata.confidence).toBe(CONFIDENCE_CONTRADICTED);
+    });
+
+    it("all patch builders return null for null entry", () => {
+      expect(buildConfirmPatch(null)).toBeNull();
+      expect(buildCorrectPatch(null)).toBeNull();
+      expect(buildContradictPatch(null)).toBeNull();
+    });
+
+    it("caps confidence history at 20 entries", () => {
+      const longHistory = Array.from({ length: 25 }, (_, i) => ({
+        action: "confirmed",
+        from: 0.5,
+        to: 1.0,
+        date: `2026-01-${String(i + 1).padStart(2, "0")}`,
+      }));
+      const entry = makeEntry("e1", "test", {
+        metadata: JSON.stringify({ confidence: 0.5, confidence_history: longHistory }),
+      });
+      const patch = buildConfirmPatch(entry);
+      const history = patch!.metadata.confidence_history as unknown[];
+      expect(history.length).toBeLessThanOrEqual(20);
+    });
+  });
+
   describe("confidence history", () => {
     it("accumulates multiple changes", async () => {
       const entry = makeEntry("e1", "evolving fact");

package/src/__tests__/consolidation-engine.test.ts

@@ -152,7 +152,7 @@ describe("ConsolidationEngine", () => {
 
   it("skips archived entries", async () => {
     const entryA = makeEntry({ id: "a", text: "active entry here", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "archived entry here", vector: [0.95, 0.1, 0], metadata: JSON.stringify({ state: "archived" }) });
+    const entryB = makeEntry({ id: "b", text: "archived entry here", vector: [0.95, 0.1, 0], metadata: JSON.stringify({ evolution: { status: "archived" } }) });
 
     const { store } = createMockStore([entryA, entryB]);
     const engine = new ConsolidationEngine(store);