claude-memory-layer 1.0.11 → 1.0.12

package/tests/retriever.memu-adoption.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import { Retriever } from '../src/core/retriever.js';
+import type { MemoryEvent, MatchResult } from '../src/core/types.js';
+import type { SearchResult } from '../src/core/vector-store.js';
+
+class FakeEventStore {
+  constructor(private readonly events: Record<string, MemoryEvent>) {}
+
+  async getEvent(id: string): Promise<MemoryEvent | null> {
+    return this.events[id] || null;
+  }
+
+  async getSessionEvents(sessionId: string): Promise<MemoryEvent[]> {
+    return Object.values(this.events).filter((e) => e.sessionId === sessionId);
+  }
+
+  async getRecentEvents(): Promise<MemoryEvent[]> {
+    return Object.values(this.events);
+  }
+
+  async keywordSearch(query: string): Promise<Array<{ event: MemoryEvent; rank: number }>> {
+    const lowered = query.toLowerCase();
+    const matches = Object.values(this.events)
+      .filter((event) => event.content.toLowerCase().includes(lowered))
+      .map((event, index) => ({ event, rank: -(index + 1) }));
+    return matches;
+  }
+}
+
+class FakeVectorStore {
+  constructor(private readonly results: SearchResult[]) {}
+
+  async search(): Promise<SearchResult[]> {
+    return this.results;
+  }
+}
+
+class FakeEmbedder {
+  async embed(): Promise<{ vector: number[] }> {
+    return { vector: [0.1, 0.2, 0.3] };
+  }
+}
+
+class FakeMatcher {
+  matchSearchResults(results: SearchResult[]): MatchResult {
+    if (results.length === 0) {
+      return { match: null, confidence: 'none' };
+    }
+
+    const top = results[0];
+    return {
+      match: {
+        event: {
+          id: top.eventId,
+          eventType: top.eventType as MemoryEvent['eventType'],
+          sessionId: top.sessionId,
+          timestamp: new Date(top.timestamp),
+          content: top.content,
+          canonicalKey: top.eventId,
+          dedupeKey: top.eventId,
+          metadata: {}
+        },
+        score: top.score
+      },
+      confidence: 'suggested'
+    };
+  }
+}
+
+function makeEvent(id: string, content: string, metadata?: Record<string, unknown>): MemoryEvent {
+  return {
+    id,
+    eventType: 'user_prompt',
+    sessionId: 's1',
+    timestamp: new Date('2026-01-01T00:00:00.000Z'),
+    content,
+    canonicalKey: id,
+    dedupeKey: id,
+    metadata
+  };
+}
+
+describe('Retriever memU-inspired enhancements', () => {
+  it('applies metadata scope filter with hierarchical key path', async () => {
+    const e1 = makeEvent('e1', 'first memory', { scope: { project: { id: 'alpha' } } });
+    const e2 = makeEvent('e2', 'second memory', { scope: { project: { id: 'beta' } } });
+
+    const retriever = new Retriever(
+      new FakeEventStore({ e1, e2 }) as any,
+      new FakeVectorStore([
+        { id: '1', eventId: 'e1', content: e1.content, score: 0.9, sessionId: 's1', eventType: e1.eventType, timestamp: e1.timestamp.toISOString() },
+        { id: '2', eventId: 'e2', content: e2.content, score: 0.89, sessionId: 's1', eventType: e2.eventType, timestamp: e2.timestamp.toISOString() }
+      ]) as any,
+      new FakeEmbedder() as any,
+      new FakeMatcher() as any
+    );
+
+    const result = await retriever.retrieve('memory', {
+      scope: { metadata: { 'scope.project.id': 'alpha' } }
+    });
+
+    expect(result.memories).toHaveLength(1);
+    expect(result.memories[0].event.id).toBe('e1');
+  });
+
+  it('uses fast strategy keyword retrieval when requested', async () => {
+    const e1 = makeEvent('e1', 'fix deployment issue with nginx');
+    const e2 = makeEvent('e2', 'random unrelated text');
+
+    const retriever = new Retriever(
+      new FakeEventStore({ e1, e2 }) as any,
+      new FakeVectorStore([]) as any,
+      new FakeEmbedder() as any,
+      new FakeMatcher() as any
+    );
+
+    const result = await retriever.retrieve('deployment', { strategy: 'fast', topK: 5 });
+
+    expect(result.memories.length).toBeGreaterThan(0);
+    expect(result.memories[0].event.id).toBe('e1');
+  });
+});

package/tests/sqlite-event-store-replication.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for SQLiteEventStore replication helpers used by Mongo sync.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+import { SQLiteEventStore } from '../src/core/sqlite-event-store.js';
+
+describe('SQLiteEventStore replication helpers', () => {
+  let tempDir: string;
+  let storeA: SQLiteEventStore;
+  let storeB: SQLiteEventStore;
+
+  beforeEach(async () => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-memory-layer-test-'));
+    storeA = new SQLiteEventStore(path.join(tempDir, 'a.sqlite'));
+    storeB = new SQLiteEventStore(path.join(tempDir, 'b.sqlite'));
+    await storeA.initialize();
+    await storeB.initialize();
+  });
+
+  afterEach(() => {
+    try { storeA.close(); } catch {}
+    try { storeB.close(); } catch {}
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('getEventsSinceRowid returns incremental batches in insertion order', async () => {
+    const sessionId = 'session-1';
+
+    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'a' });
+    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'b' });
+    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'c' });
+
+    const batch1 = await storeA.getEventsSinceRowid(0, 10);
+    expect(batch1).toHaveLength(3);
+    expect(batch1.map(x => x.event.content)).toEqual(['a', 'b', 'c']);
+
+    // rowid should be strictly increasing
+    expect(batch1[0].rowid).toBeLessThan(batch1[1].rowid);
+    expect(batch1[1].rowid).toBeLessThan(batch1[2].rowid);
+
+    const lastRowid = batch1[2].rowid;
+
+    await storeA.append({ eventType: 'user_prompt', sessionId, timestamp: new Date(), content: 'd' });
+
+    const batch2 = await storeA.getEventsSinceRowid(lastRowid, 10);
+    expect(batch2).toHaveLength(1);
+    expect(batch2[0].event.content).toBe('d');
+  });
+
+  it('importEvents preserves stable IDs and is idempotent via dedupeKey', async () => {
+    const sessionId = 'session-2';
+    const appendRes = await storeA.append({
+      eventType: 'user_prompt',
+      sessionId,
+      timestamp: new Date(),
+      content: 'hello world'
+    });
+
+    expect(appendRes.success).toBe(true);
+    const sourceEvent = await storeA.getEvent(appendRes.eventId!);
+    expect(sourceEvent).not.toBeNull();
+
+    const imported1 = await storeB.importEvents([sourceEvent!]);
+    expect(imported1.inserted).toBe(1);
+    expect(imported1.skipped).toBe(0);
+
+    const importedEvent = await storeB.getEvent(sourceEvent!.id);
+    expect(importedEvent?.content).toBe('hello world');
+
+    // Importing again should be a no-op
+    const imported2 = await storeB.importEvents([sourceEvent!]);
+    expect(imported2.inserted).toBe(0);
+    expect(imported2.skipped).toBe(1);
+
+    // append() should treat it as duplicate due to event_dedup entry
+    const dup = await storeB.append({
+      eventType: 'user_prompt',
+      sessionId,
+      timestamp: new Date(),
+      content: 'hello world'
+    });
+    expect(dup.success).toBe(true);
+    expect(dup.isDuplicate).toBe(true);
+    expect(dup.eventId).toBe(sourceEvent!.id);
+  });
+});
+