recallnest 2.3.0 → 2.6.0

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

@@ -0,0 +1,418 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { summarizeConflictAdvice } from "../conflict-advisor.js";
+import { buildConflictCandidateRecord, resolveConflictCandidate } from "../conflict-engine.js";
+import { ConflictCandidateStore } from "../conflict-store.js";
+import { parseEvolution } from "../memory-evolution.js";
+
+const tempDirs: string[] = [];
+
+function createTempConflictStore(): ConflictCandidateStore {
+  const dir = mkdtempSync(join(tmpdir(), "recallnest-conflicts-"));
+  tempDirs.push(dir);
+  return new ConflictCandidateStore(dir);
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function createConflictRecord() {
+  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 replies.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+      }),
+      canonicalKey: "user-reply-style",
+    },
+    incoming: {
+      text: "User prefers colloquial writing that stays grounded and non-salesy.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.78,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+        promotedFrom: {
+          memoryId: "source-1",
+          scope: "cc:session-1",
+          category: "events",
+        },
+      }),
+      source: "agent",
+      sourceMemoryId: "source-1",
+      sourceCategory: "events",
+    },
+  });
+}
+
+function createMergeableConflictRecord() {
+  return buildConflictCandidateRecord({
+    canonicalKey: "user-reply-style",
+    category: "preferences",
+    fingerprint: "user-reply-style--durable-1--source-1--mergeable",
+    reason: "promotion_conflicts_with_existing_durable",
+    existing: {
+      memoryId: "durable-1",
+      text: "User prefers concise grounded technical replies; avoid sales language.",
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      metadata: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+      }),
+      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: JSON.stringify({
+        source: "agent",
+        canonicalKey: "user-reply-style",
+        boundary: {
+          layer: "durable",
+          authority: "structured-memory",
+          conflictPolicy: "latest-wins",
+          originalCategory: "preferences",
+        },
+        promotedFrom: {
+          memoryId: "source-1",
+          scope: "cc:session-1",
+          category: "events",
+        },
+      }),
+      source: "agent",
+      sourceMemoryId: "source-1",
+      sourceCategory: "events",
+    },
+  });
+}
+
+describe("ConflictCandidateStore", () => {
+  it("saves, lists, and fetches open conflicts by fingerprint", async () => {
+    const store = createTempConflictStore();
+    const record = createConflictRecord();
+    await store.save(record);
+
+    const fetched = await store.getById(record.conflictId);
+    expect(fetched?.conflictId).toBe(record.conflictId);
+
+    const byFingerprint = await store.getOpenByFingerprint(record.fingerprint);
+    expect(byFingerprint?.conflictId).toBe(record.conflictId);
+
+    const recent = await store.listRecent({
+      status: "open",
+      canonicalKey: "user-reply-style",
+      limit: 10,
+    });
+    expect(recent).toHaveLength(1);
+    expect(recent[0]?.conflictId).toBe(record.conflictId);
+  });
+
+  it("accepts a unique short conflict ID prefix", async () => {
+    const store = createTempConflictStore();
+    const record = createConflictRecord();
+    await store.save(record);
+
+    const fetched = await store.getById(record.conflictId.slice(0, 8));
+    expect(fetched?.conflictId).toBe(record.conflictId);
+  });
+});
+
+describe("resolveConflictCandidate", () => {
+  it("accepts incoming text and updates the existing durable memory", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = createConflictRecord();
+    await conflictStore.save(record);
+
+    const updatedPayloads: any[] = [];
+    const archivedRows: any[] = [];
+    const originalExistingText = "User prefers concise, direct replies.";
+    const existingMemory = {
+      id: "durable-1",
+      text: originalExistingText,
+      vector: [1, 1, 1],
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      timestamp: 1_700_000_000_001,
+      metadata: record.existing.metadata,
+    };
+
+    const result = await resolveConflictCandidate({
+      store: {
+        async getById(id: string) {
+          return id === existingMemory.id ? existingMemory : null;
+        },
+        async update(id: string, updates: any) {
+          updatedPayloads.push({ id, updates });
+          Object.assign(existingMemory, updates);
+          return existingMemory;
+        },
+        async store(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
+        async upsert(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
+      },
+      embedder: {
+        async embedPassage(text: string) {
+          return [text.length, 9, 9];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "accept_incoming",
+      notes: "Promoted evidence is cleaner than the original durable wording.",
+    });
+
+    expect(result.status).toBe("accepted-incoming");
+    expect(result.updatedMemoryId).toBe("durable-1");
+    expect(updatedPayloads).toHaveLength(1);
+    expect(updatedPayloads[0]?.updates.text).toBe(record.incoming.text);
+
+    // The incoming metadata is carried through, with an evolution block layered on top
+    // that links the live row back to the archived version (it is no longer passed verbatim).
+    const incomingMeta = JSON.parse(record.incoming.metadata);
+    const writtenMeta = JSON.parse(updatedPayloads[0]?.updates.metadata);
+    for (const [key, value] of Object.entries(incomingMeta)) {
+      if (key === "evolution") continue;
+      expect(writtenMeta[key]).toEqual(value);
+    }
+
+    // Accepting the incoming version must not destroy the belief it replaced.
+    expect(archivedRows).toHaveLength(1);
+    expect(archivedRows[0].text).toBe(originalExistingText);
+    const archivedEvo = parseEvolution(archivedRows[0].metadata);
+    expect(archivedEvo.status).toBe("superseded");
+    expect(archivedEvo.supersededBy).toBe("durable-1");
+    expect(parseEvolution(updatedPayloads[0]?.updates.metadata).supersedes).toBe(archivedRows[0].id);
+
+    const resolved = await conflictStore.getById(record.conflictId);
+    expect(resolved?.status).toBe("accepted-incoming");
+    expect(resolved?.resolutionNotes).toContain("cleaner");
+  });
+
+  it("can keep the existing durable memory without updating it", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = createConflictRecord();
+    await conflictStore.save(record);
+
+    let updated = false;
+    const result = await resolveConflictCandidate({
+      store: {
+        async getById() {
+          return null;
+        },
+        async update() {
+          updated = true;
+          return null;
+        },
+      },
+      embedder: {
+        async embedPassage() {
+          return [0, 0, 0];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "keep_existing",
+    });
+
+    expect(result.status).toBe("kept-existing");
+    expect(updated).toBe(false);
+
+    const resolved = await conflictStore.getById(record.conflictId);
+    expect(resolved?.status).toBe("kept-existing");
+  });
+
+  it("merges same-category conflicts using the default merge suggestion", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = createMergeableConflictRecord();
+    await conflictStore.save(record);
+
+    const updatedPayloads: any[] = [];
+    const existingMemory = {
+      id: "durable-1",
+      text: record.existing.text,
+      vector: [1, 1, 1],
+      category: "preferences",
+      scope: "memory:agent",
+      importance: 0.84,
+      timestamp: 1_700_000_000_001,
+      metadata: record.existing.metadata,
+    };
+
+    const mergeSuggestion = summarizeConflictAdvice(record).mergeSuggestion;
+    expect(mergeSuggestion).toBeTruthy();
+    const archivedRows: any[] = [];
+    const originalExistingText = existingMemory.text;
+
+    const result = await resolveConflictCandidate({
+      store: {
+        async getById(id: string) {
+          return id === existingMemory.id ? existingMemory : null;
+        },
+        async update(id: string, updates: any) {
+          updatedPayloads.push({ id, updates });
+          Object.assign(existingMemory, updates);
+          return existingMemory;
+        },
+        async store(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
+        async upsert(entry: any) {
+          archivedRows.push(entry);
+          return entry;
+        },
+      },
+      embedder: {
+        async embedPassage(text: string) {
+          return [text.length, 7, 7];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "merge",
+      notes: "Combine the grounded style and tone guidance.",
+    });
+
+    expect(result.status).toBe("merged");
+    expect(result.updatedMemoryId).toBe("durable-1");
+    expect(updatedPayloads).toHaveLength(1);
+    expect(updatedPayloads[0]?.updates.text).toBe(mergeSuggestion);
+    expect(updatedPayloads[0]?.updates.importance).toBe(0.84);
+
+    const mergedMetadata = JSON.parse(updatedPayloads[0]?.updates.metadata || "{}");
+    expect(mergedMetadata.canonicalKey).toBe("user-reply-style");
+    expect(mergedMetadata.promotedFrom?.memoryId).toBe("source-1");
+    expect(mergedMetadata.mergedFrom?.conflictId).toBe(record.conflictId);
+
+    // A merge still replaces the existing row's text, so the pre-merge belief must survive
+    // as history — otherwise the "before" half of the merge decision is unrecoverable.
+    expect(archivedRows).toHaveLength(1);
+    expect(archivedRows[0].text).toBe(originalExistingText);
+    expect(parseEvolution(archivedRows[0].metadata).status).toBe("superseded");
+    expect(parseEvolution(updatedPayloads[0]?.updates.metadata).supersedes).toBe(archivedRows[0].id);
+
+    const resolved = await conflictStore.getById(record.conflictId);
+    expect(resolved?.status).toBe("merged");
+    expect(resolved?.resolutionNotes).toContain("grounded style");
+  });
+
+  it("rejects merge for cross-category conflicts", async () => {
+    const conflictStore = createTempConflictStore();
+    const record = buildConflictCandidateRecord({
+      canonicalKey: "project-owner",
+      category: "events",
+      fingerprint: "project-owner--durable-1--source-2--cross-category",
+      reason: "canonical_key_conflicts_with_existing_durable",
+      existing: {
+        memoryId: "durable-1",
+        text: "Project owner: RecallNest",
+        category: "entities",
+        scope: "memory:agent",
+        importance: 0.82,
+        metadata: recordLikeMetadata("project-owner", "entities"),
+        canonicalKey: "project-owner",
+      },
+      incoming: {
+        text: "Project owner observation imported as an event.",
+        category: "events",
+        scope: "memory:agent",
+        importance: 0.74,
+        metadata: recordLikeMetadata("project-owner", "events"),
+        source: "agent",
+        sourceMemoryId: "source-2",
+        sourceCategory: "events",
+      },
+    });
+    await conflictStore.save(record);
+
+    await expect(resolveConflictCandidate({
+      store: {
+        async getById() {
+          return {
+            id: "durable-1",
+            text: "Project owner: RecallNest",
+            vector: [1, 1, 1],
+            category: "entities",
+            scope: "memory:agent",
+            importance: 0.82,
+            timestamp: 1_700_000_000_002,
+            metadata: record.existing.metadata,
+          };
+        },
+        async update() {
+          throw new Error("update should not be called");
+        },
+      },
+      embedder: {
+        async embedPassage() {
+          return [0, 0, 0];
+        },
+      },
+      conflictStore,
+    }, {
+      conflictId: record.conflictId,
+      resolution: "merge",
+    })).rejects.toThrow("same-category durable conflicts");
+  });
+});
+
+function recordLikeMetadata(canonicalKey: string, category: string): string {
+  return JSON.stringify({
+    source: "agent",
+    canonicalKey,
+    boundary: {
+      layer: "durable",
+      authority: "structured-memory",
+      conflictPolicy: "latest-wins",
+      originalCategory: category,
+    },
+  });
+}

package/src/__tests__/connector-v1.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  detectFormat,
+  normalizeConnectorV1,
+  normalizeConversation,
+} from "../conversation-importer.js";
+import { isConnectorOutputV1, type ConnectorOutputV1 } from "../connector-types.js";
+
+// ---------------------------------------------------------------------------
+// isConnectorOutputV1 validator
+// ---------------------------------------------------------------------------
+
+describe("isConnectorOutputV1", () => {
+  it("validates a correct connector-v1 payload", () => {
+    const valid: ConnectorOutputV1 = {
+      version: "connector-v1",
+      source: "obsidian",
+      scope: "vault:notes",
+      producedAt: "2026-04-13T00:00:00Z",
+      records: [{ id: "r1", text: "hello" }],
+    };
+    expect(isConnectorOutputV1(valid)).toBe(true);
+  });
+
+  it("rejects null / undefined / non-objects", () => {
+    expect(isConnectorOutputV1(null)).toBe(false);
+    expect(isConnectorOutputV1(undefined)).toBe(false);
+    expect(isConnectorOutputV1("string")).toBe(false);
+    expect(isConnectorOutputV1(42)).toBe(false);
+  });
+
+  it("rejects objects with wrong version", () => {
+    expect(isConnectorOutputV1({ version: "v2", source: "x", scope: "y", producedAt: "z", records: [] })).toBe(false);
+  });
+
+  it("rejects objects missing required fields", () => {
+    expect(isConnectorOutputV1({ version: "connector-v1" })).toBe(false);
+    expect(isConnectorOutputV1({ version: "connector-v1", source: "x" })).toBe(false);
+    expect(isConnectorOutputV1({ version: "connector-v1", source: "x", scope: "y", producedAt: "z" })).toBe(false);
+  });
+
+  it("accepts empty records array", () => {
+    expect(isConnectorOutputV1({
+      version: "connector-v1",
+      source: "test",
+      scope: "test:scope",
+      producedAt: "2026-04-13T00:00:00Z",
+      records: [],
+    })).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// detectFormat — connector-v1
+// ---------------------------------------------------------------------------
+
+describe("detectFormat — connector-v1", () => {
+  it("detects connector-v1 JSON", () => {
+    const payload = JSON.stringify({
+      version: "connector-v1",
+      source: "obsidian",
+      scope: "vault:my-notes",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [{ id: "r1", text: "test" }],
+    });
+    expect(detectFormat(payload)).toBe("connector-v1");
+  });
+
+  it("detects connector-v1 with optional fields", () => {
+    const payload = JSON.stringify({
+      version: "connector-v1",
+      source: "email",
+      scope: "inbox:main",
+      batchId: "batch-001",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [],
+    });
+    expect(detectFormat(payload)).toBe("connector-v1");
+  });
+
+  it("does not misidentify non-connector JSON as connector-v1", () => {
+    // claude-ai format
+    const claudeAi = JSON.stringify({ chat_conversations: [{ chat_messages: [] }] });
+    expect(detectFormat(claudeAi)).toBe("claude-ai");
+
+    // chatgpt format
+    const chatgpt = JSON.stringify({ mapping: {} });
+    expect(detectFormat(chatgpt)).toBe("chatgpt");
+  });
+
+  it("connector-v1 takes priority over other single-object formats", () => {
+    // An object that has both connector-v1 fields AND a mapping field
+    const hybrid = JSON.stringify({
+      version: "connector-v1",
+      source: "test",
+      scope: "test:s",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [],
+      mapping: {},  // chatgpt field — should not override
+    });
+    expect(detectFormat(hybrid)).toBe("connector-v1");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// normalizeConnectorV1
+// ---------------------------------------------------------------------------
+
+describe("normalizeConnectorV1", () => {
+  it("normalizes records with title and text", () => {
+    const payload: ConnectorOutputV1 = {
+      version: "connector-v1",
+      source: "obsidian",
+      scope: "vault:notes",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [
+        { id: "r1", text: "Some content", title: "My Note" },
+        { id: "r2", text: "Another note" },
+      ],
+    };
+    const messages = normalizeConnectorV1(JSON.stringify(payload));
+    expect(messages).toHaveLength(2);
+    expect(messages[0].content).toBe("[My Note] Some content");
+    expect(messages[0].role).toBe("user");
+    expect(messages[1].content).toBe("Another note");
+  });
+
+  it("preserves timestamps", () => {
+    const payload: ConnectorOutputV1 = {
+      version: "connector-v1",
+      source: "test",
+      scope: "test:s",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [
+        { id: "r1", text: "hello", timestamp: "2026-04-12T10:00:00Z" },
+        { id: "r2", text: "world" },
+      ],
+    };
+    const messages = normalizeConnectorV1(JSON.stringify(payload));
+    expect(messages[0].timestamp).toBe("2026-04-12T10:00:00Z");
+    expect(messages[1].timestamp).toBeUndefined();
+  });
+
+  it("returns empty array for empty records", () => {
+    const payload: ConnectorOutputV1 = {
+      version: "connector-v1",
+      source: "test",
+      scope: "test:s",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [],
+    };
+    const messages = normalizeConnectorV1(JSON.stringify(payload));
+    expect(messages).toHaveLength(0);
+  });
+
+  it("throws on invalid connector-v1 JSON", () => {
+    expect(() => normalizeConnectorV1(JSON.stringify({ version: "v2" }))).toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// normalizeConversation dispatch
+// ---------------------------------------------------------------------------
+
+describe("normalizeConversation — connector-v1 dispatch", () => {
+  it("dispatches connector-v1 through normalizeConversation", () => {
+    const payload: ConnectorOutputV1 = {
+      version: "connector-v1",
+      source: "rss",
+      scope: "feed:tech",
+      producedAt: "2026-04-13T12:00:00Z",
+      records: [
+        { id: "r1", text: "Article body", title: "Cool Article" },
+      ],
+    };
+    const messages = normalizeConversation(JSON.stringify(payload), "connector-v1");
+    expect(messages).toHaveLength(1);
+    expect(messages[0].content).toBe("[Cool Article] Article body");
+  });
+});