recallnest 3.0.0 → 3.0.1

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

@@ -1,125 +0,0 @@
-/**
- * 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

@@ -1,261 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-  confirmMemory,
-  correctMemory,
-  contradictMemory,
-  buildConfirmPatch,
-  buildCorrectPatch,
-  buildContradictPatch,
-  getConfidence,
-  applyConfidenceWeight,
-  CONFIDENCE_DEFAULT,
-  CONFIDENCE_CONFIRMED,
-  CONFIDENCE_CORRECTED,
-  CONFIDENCE_CONTRADICTED,
-} from "../confidence-tracker.js";
-import type { MemoryEntry } from "../store.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeEntry(id: string, text: string, overrides: Partial<MemoryEntry> = {}): MemoryEntry {
-  return {
-    id,
-    text,
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: "{}",
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[]) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata?: string }> = [];
-
-  // 模拟 store.patchMetadata 单写通道:读最新 metadata → patchFn → 写回。
-  return {
-    updates,
-    data,
-    async patchMetadata(
-      id: string,
-      patchFn: (meta: Record<string, unknown>, entry: MemoryEntry) => Record<string, unknown>,
-      _scopeFilter?: string[],
-    ) {
-      const entry = data.get(id);
-      if (!entry) return null;
-      let meta: Record<string, unknown>;
-      try {
-        const parsed: unknown = JSON.parse(entry.metadata || "{}");
-        meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)
-          ? (parsed as Record<string, unknown>)
-          : {};
-      } catch {
-        meta = {};
-      }
-      const patched = patchFn(meta, entry);
-      entry.metadata = JSON.stringify(patched);
-      updates.push({ id, metadata: entry.metadata });
-      return entry;
-    },
-  } as any;
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("confidence-tracker", () => {
-  describe("getConfidence", () => {
-    it("returns default for entries without confidence", () => {
-      const entry = makeEntry("e1", "test");
-      expect(getConfidence(entry)).toBe(CONFIDENCE_DEFAULT);
-    });
-
-    it("returns stored confidence", () => {
-      const entry = makeEntry("e1", "test", {
-        metadata: JSON.stringify({ confidence: 0.9 }),
-      });
-      expect(getConfidence(entry)).toBe(0.9);
-    });
-
-    it("returns default for malformed metadata", () => {
-      const entry = makeEntry("e1", "test", { metadata: "not-json" });
-      expect(getConfidence(entry)).toBe(CONFIDENCE_DEFAULT);
-    });
-  });
-
-  describe("confirmMemory", () => {
-    it("sets confidence to 1.0", async () => {
-      const entry = makeEntry("e1", "user likes TypeScript");
-      const store = createMockStore([entry]);
-
-      const result = await confirmMemory(store, "e1", "project:test");
-      expect(result).not.toBeNull();
-      expect(result!.newConfidence).toBe(CONFIDENCE_CONFIRMED);
-      expect(result!.oldConfidence).toBe(CONFIDENCE_DEFAULT);
-
-      const meta = JSON.parse(store.data.get("e1")!.metadata!);
-      expect(meta.confidence).toBe(1.0);
-      expect(meta.confidence_history).toHaveLength(1);
-      expect(meta.confidence_history[0].action).toBe("confirmed");
-    });
-
-    it("returns null for missing entry", async () => {
-      const store = createMockStore([]);
-      const result = await confirmMemory(store, "missing", "project:test");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("correctMemory", () => {
-    it("drops confidence to 0.3", async () => {
-      const entry = makeEntry("e1", "user uses Python");
-      const store = createMockStore([entry]);
-
-      const result = await correctMemory(store, "e1", "project:test", "new-entry-id");
-      expect(result).not.toBeNull();
-      expect(result!.newConfidence).toBe(CONFIDENCE_CORRECTED);
-
-      const meta = JSON.parse(store.data.get("e1")!.metadata!);
-      expect(meta.confidence).toBe(0.3);
-      expect(meta.corrected_by).toBe("new-entry-id");
-      expect(meta.confidence_history[0].correctedBy).toBe("new-entr"); // 8 chars
-    });
-
-    it("works without correctedById", async () => {
-      const entry = makeEntry("e1", "old info");
-      const store = createMockStore([entry]);
-
-      const result = await correctMemory(store, "e1", "project:test");
-      expect(result!.newConfidence).toBe(CONFIDENCE_CORRECTED);
-
-      const meta = JSON.parse(store.data.get("e1")!.metadata!);
-      expect(meta.corrected_by).toBeUndefined();
-    });
-  });
-
-  describe("contradictMemory", () => {
-    it("drops confidence to 0.0", async () => {
-      const entry = makeEntry("e1", "wrong fact");
-      const store = createMockStore([entry]);
-
-      const result = await contradictMemory(store, "e1", "project:test");
-      expect(result).not.toBeNull();
-      expect(result!.newConfidence).toBe(CONFIDENCE_CONTRADICTED);
-
-      const meta = JSON.parse(store.data.get("e1")!.metadata!);
-      expect(meta.confidence).toBe(0.0);
-    });
-  });
-
-  describe("applyConfidenceWeight", () => {
-    it("no penalty at confidence=1.0", () => {
-      const entry = makeEntry("e1", "test", {
-        metadata: JSON.stringify({ confidence: 1.0 }),
-      });
-      expect(applyConfidenceWeight(1.0, entry)).toBe(1.0);
-    });
-
-    it("slight penalty at default confidence=0.7", () => {
-      const entry = makeEntry("e1", "test");
-      const weighted = applyConfidenceWeight(1.0, entry);
-      expect(weighted).toBeCloseTo(0.85, 2);
-    });
-
-    it("significant penalty at corrected confidence=0.3", () => {
-      const entry = makeEntry("e1", "test", {
-        metadata: JSON.stringify({ confidence: 0.3 }),
-      });
-      const weighted = applyConfidenceWeight(1.0, entry);
-      expect(weighted).toBeCloseTo(0.65, 2);
-    });
-
-    it("heavy penalty at contradicted confidence=0.0", () => {
-      const entry = makeEntry("e1", "test", {
-        metadata: JSON.stringify({ confidence: 0.0 }),
-      });
-      const weighted = applyConfidenceWeight(1.0, entry);
-      expect(weighted).toBe(0.5);
-    });
-
-    it("scales with input score", () => {
-      const entry = makeEntry("e1", "test", {
-        metadata: JSON.stringify({ confidence: 0.3 }),
-      });
-      const weighted = applyConfidenceWeight(0.8, entry);
-      expect(weighted).toBeCloseTo(0.8 * 0.65, 2);
-    });
-  });
-
-  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");
-      const store = createMockStore([entry]);
-
-      await correctMemory(store, "e1", "project:test");
-      await confirmMemory(store, "e1", "project:test");
-
-      const meta = JSON.parse(store.data.get("e1")!.metadata!);
-      expect(meta.confidence_history).toHaveLength(2);
-      expect(meta.confidence_history[0].action).toBe("corrected");
-      expect(meta.confidence_history[1].action).toBe("confirmed");
-      expect(meta.confidence).toBe(CONFIDENCE_CONFIRMED);
-    });
-  });
-});

package/src/__tests__/conflict-advisor.test.ts

@@ -1,206 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { buildConflictCandidateRecord } from "../conflict-engine.js";
-import { buildConflictAuditSummary, clusterConflicts, summarizeConflictAdvice } from "../conflict-advisor.js";
-
-/** Returns an ISO timestamp N days before now (defaults to 4 days = firmly "stale"). */
-function daysAgo(n: number): string {
-  return new Date(Date.now() - n * 24 * 60 * 60 * 1000).toISOString();
-}
-
-function createConflictRecord(overrides: Record<string, unknown> = {}) {
-  const defaultTs = daysAgo(4); // 4 days ago → "stale" (3-6 days range)
-  return {
-    ...buildConflictCandidateRecord({
-      canonicalKey: "user-reply-style",
-      category: "preferences",
-      fingerprint: "user-reply-style--durable-1--source-1--new-text",
-      reason: "promotion_conflicts_with_existing_durable",
-      existing: {
-        memoryId: "durable-1",
-        text: "User prefers concise, direct, technical replies.",
-        category: "preferences",
-        scope: "memory:agent",
-        importance: 0.84,
-        metadata: "{\"source\":\"agent\"}",
-        canonicalKey: "user-reply-style",
-      },
-      incoming: {
-        text: "User prefers concise direct technical replies.",
-        category: "preferences",
-        scope: "memory:agent",
-        importance: 0.78,
-        metadata: "{\"source\":\"agent\"}",
-        source: "agent",
-        sourceMemoryId: "source-1",
-        sourceCategory: "events",
-      },
-      createdAt: defaultTs,
-      updatedAt: defaultTs,
-    }),
-    ...overrides,
-  };
-}
-
-describe("summarizeConflictAdvice", () => {
-  it("suggests keep_existing for text-equivalent conflicts", () => {
-    const advice = summarizeConflictAdvice(createConflictRecord() as any);
-
-    expect(advice.suggestedResolution).toBe("keep_existing");
-    expect(advice.confidence).toBe("high");
-    expect(advice.similarity).toBe(1);
-  });
-
-  it("suggests keep_existing for cross-category canonical key conflicts", () => {
-    const advice = summarizeConflictAdvice(createConflictRecord({
-      reason: "canonical_key_conflicts_with_existing_durable",
-      category: "events",
-      incoming: {
-        text: "Reply-style observation imported as an event.",
-        category: "events",
-        scope: "memory:agent",
-        importance: 0.78,
-        metadata: "{\"source\":\"agent\"}",
-        source: "agent",
-        sourceMemoryId: "source-2",
-        sourceCategory: "events",
-      },
-    }) as any);
-
-    expect(advice.suggestedResolution).toBe("keep_existing");
-    expect(["medium", "high"]).toContain(advice.confidence);
-    expect(advice.reasons.some((reason) => reason.includes("canonical key"))).toBe(true);
-  });
-
-  it("suggests accept_incoming when the incoming text is a tighter rewrite of the same memory", () => {
-    const advice = summarizeConflictAdvice(createConflictRecord({
-      existing: {
-        memoryId: "durable-1",
-        text: "User prefers concise grounded technical replies and avoids sales language in the final copy.",
-        category: "preferences",
-        scope: "memory:agent",
-        importance: 0.84,
-        metadata: "{\"source\":\"agent\"}",
-        canonicalKey: "user-reply-style",
-      },
-      incoming: {
-        text: "User prefers concise grounded technical replies and avoids sales language.",
-        category: "preferences",
-        scope: "memory:agent",
-        importance: 0.78,
-        metadata: "{\"source\":\"agent\"}",
-        source: "agent",
-        sourceMemoryId: "source-1",
-        sourceCategory: "events",
-      },
-    }) as any);
-
-    expect(advice.suggestedResolution).toBe("accept_incoming");
-    expect(advice.confidence).toBe("medium");
-    expect(advice.similarity).toBeGreaterThanOrEqual(0.72);
-    expect(advice.mergeSuggestion).toBeUndefined();
-  });
-
-  it("offers a merged wording suggestion for same-category manual_review conflicts", () => {
-    const advice = summarizeConflictAdvice(createConflictRecord({
-      existing: {
-        memoryId: "durable-1",
-        text: "User prefers concise grounded technical replies; avoid sales language.",
-        category: "preferences",
-        scope: "memory:agent",
-        importance: 0.84,
-        metadata: "{\"source\":\"agent\"}",
-        canonicalKey: "user-reply-style",
-      },
-      incoming: {
-        text: "User prefers concise grounded technical replies; keep the tone colloquial.",
-        category: "preferences",
-        scope: "memory:agent",
-        importance: 0.78,
-        metadata: "{\"source\":\"agent\"}",
-        source: "agent",
-        sourceMemoryId: "source-1",
-        sourceCategory: "events",
-      },
-    }) as any);
-
-    expect(advice.suggestedResolution).toBe("manual_review");
-    expect(advice.mergeSuggestion).toContain("User prefers concise grounded technical replies");
-    expect(advice.mergeSuggestion).toContain("avoid sales language");
-    expect(advice.mergeSuggestion).toContain("keep the tone colloquial");
-    expect(advice.reasons.some((reason) => reason.includes("merged durable wording"))).toBe(true);
-  });
-});
-
-describe("clusterConflicts", () => {
-  it("groups conflicts by canonical key, reason, and category", () => {
-    const clusters = clusterConflicts([
-      createConflictRecord({
-        conflictId: "00000000-0000-0000-0000-000000000001",
-        createdAt: daysAgo(4),
-        updatedAt: daysAgo(4),
-      }) as any,
-      createConflictRecord({
-        conflictId: "00000000-0000-0000-0000-000000000002",
-        createdAt: daysAgo(4),
-        updatedAt: daysAgo(3),
-      }) as any,
-      createConflictRecord({
-        canonicalKey: "project-entity-owner",
-        conflictId: "00000000-0000-0000-0000-000000000003",
-        fingerprint: "project-entity-owner--durable-1--source-1--new-text",
-      }) as any,
-    ]);
-
-    expect(clusters).toHaveLength(2);
-    expect(clusters[0]?.canonicalKey).toBe("user-reply-style");
-    expect(clusters[0]?.totalCount).toBe(2);
-    expect(clusters[0]?.latestConflictId).toBe("00000000-0000-0000-0000-000000000002");
-    expect(clusters[0]?.attention).toBe("stale");
-  });
-});
-
-describe("buildConflictAuditSummary", () => {
-  it("highlights escalated or stale open clusters first", () => {
-    const summary = buildConflictAuditSummary([
-      createConflictRecord({
-        conflictId: "00000000-0000-0000-0000-000000000001",
-        createdAt: daysAgo(14),
-        updatedAt: daysAgo(14),
-      }) as any,
-      createConflictRecord({
-        canonicalKey: "project-entity-owner",
-        conflictId: "00000000-0000-0000-0000-000000000002",
-        fingerprint: "project-entity-owner--durable-1--source-1--new-text",
-        createdAt: daysAgo(1),
-        updatedAt: daysAgo(1),
-      }) as any,
-      createConflictRecord({
-        conflictId: "00000000-0000-0000-0000-000000000003",
-        status: "kept-existing",
-        resolvedAt: daysAgo(0),
-        updatedAt: daysAgo(0),
-      }) as any,
-    ], 3);
-
-    expect(summary.totalConflicts).toBe(3);
-    expect(summary.openConflicts).toBe(2);
-    expect(summary.attentionCounts.resolved).toBe(1);
-    expect(summary.priorityClusters[0]?.attention).toBe("escalated");
-    expect(summary.suggestedActions.some((action) => action.includes("escalated"))).toBe(true);
-  });
-
-  it("returns a no-open-conflicts message when nothing is pending", () => {
-    const summary = buildConflictAuditSummary([
-      createConflictRecord({
-        conflictId: "00000000-0000-0000-0000-000000000001",
-        status: "kept-existing",
-        resolvedAt: "2026-03-16T00:00:00.000Z",
-      }) as any,
-    ], 3);
-
-    expect(summary.openConflicts).toBe(0);
-    expect(summary.priorityClusters).toHaveLength(0);
-    expect(summary.suggestedActions).toEqual(["No open conflicts need review."]);
-  });
-});