@prmichaelsen/remember-mcp 3.15.4 → 3.15.6

package/src/memory-crud.e2e.ts

@@ -0,0 +1,203 @@
+/**
+ * E2E: Core Memory CRUD — remember_create/search/update/delete/find_similar/query
+ *
+ * Run with:
+ *   DOTENV_CONFIG_PATH=.env.e1.local npm run test:e2e -- --testPathPattern=memory-crud
+ */
+
+import {
+  e2eInit, e2eUserId, e2eAuthContext, e2eEnsureCollection,
+  e2eCleanup, parseResult, waitForIndex,
+} from './e2e-helpers.js';
+import { handleCreateMemory } from './tools/create-memory.js';
+import { handleSearchMemory } from './tools/search-memory.js';
+import { handleUpdateMemory } from './tools/update-memory.js';
+import { handleDeleteMemory } from './tools/delete-memory.js';
+import { handleConfirm } from './tools/confirm.js';
+import { handleFindSimilar } from './tools/find-similar.js';
+import { handleQueryMemory } from './tools/query-memory.js';
+
+const userId = e2eUserId('crud');
+const auth = e2eAuthContext();
+
+describe('E2E: Memory CRUD', () => {
+  beforeAll(async () => {
+    await e2eInit();
+    await e2eEnsureCollection(userId);
+  }, 30_000);
+
+  afterAll(async () => {
+    await e2eCleanup(userId);
+  }, 30_000);
+
+  // ---- State shared across ordered tests ----
+  let memoryId: string;
+  let secondMemoryId: string;
+  let thirdMemoryId: string;
+
+  // -------------------------------------------------------------------------
+  // CREATE
+  // -------------------------------------------------------------------------
+
+  it('creates a memory', async () => {
+    const res = parseResult(await handleCreateMemory(
+      { content: 'I went camping at Yosemite last weekend. The Half Dome trail was spectacular.', weight: 0.8, trust: 0.5, tags: ['camping', 'yosemite'] },
+      userId, auth,
+    ));
+
+    expect(res.memory_id).toBeTruthy();
+    memoryId = res.memory_id;
+    console.log(`  created memory ${memoryId}`);
+  });
+
+  it('creates a second related memory', async () => {
+    const res = parseResult(await handleCreateMemory(
+      { content: 'My favorite camping gear: MSR tent, Jetboil stove, and Osprey backpack.', weight: 0.6, tags: ['camping', 'gear'] },
+      userId, auth,
+    ));
+    secondMemoryId = res.memory_id;
+  });
+
+  it('creates a third unrelated memory', async () => {
+    const res = parseResult(await handleCreateMemory(
+      { content: 'Grandma\'s chocolate chip cookie recipe: 2 cups flour, 1 cup butter, chocolate chips.', weight: 0.7, tags: ['recipe', 'cookies'] },
+      userId, auth,
+    ));
+    thirdMemoryId = res.memory_id;
+  });
+
+  // -------------------------------------------------------------------------
+  // SEARCH (hybrid)
+  // -------------------------------------------------------------------------
+
+  it('searches and finds the camping memory via hybrid search', async () => {
+    await waitForIndex();
+
+    const res = parseResult(await handleSearchMemory(
+      { query: 'camping yosemite half dome', limit: 10 },
+      userId, auth,
+    ));
+
+    expect(res.memories.length).toBeGreaterThan(0);
+    const ids = res.memories.map((m: any) => m.id);
+    expect(ids).toContain(memoryId);
+    console.log(`  search returned ${res.memories.length} memories`);
+  });
+
+  it('does not return unrelated memories first', async () => {
+    const res = parseResult(await handleSearchMemory(
+      { query: 'camping trip outdoors', limit: 5 },
+      userId, auth,
+    ));
+
+    // Cookie recipe should not be the top result
+    if (res.memories.length > 0) {
+      expect(res.memories[0].id).not.toBe(thirdMemoryId);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // UPDATE
+  // -------------------------------------------------------------------------
+
+  it('updates the memory content', async () => {
+    const res = parseResult(await handleUpdateMemory(
+      { memory_id: memoryId, content: 'I went camping at Yosemite last weekend. The Half Dome trail was spectacular. We saw a bear!', tags: ['camping', 'yosemite', 'wildlife'] },
+      userId, auth,
+    ));
+
+    expect(res.memory_id).toBe(memoryId);
+    expect(res.version).toBeGreaterThan(1);
+  });
+
+  it('search reflects updated content', async () => {
+    await waitForIndex();
+
+    const res = parseResult(await handleSearchMemory(
+      { query: 'bear wildlife camping', limit: 5 },
+      userId, auth,
+    ));
+
+    const found = res.memories.find((m: any) => m.id === memoryId);
+    expect(found).toBeTruthy();
+    expect(found.content).toContain('bear');
+  });
+
+  // -------------------------------------------------------------------------
+  // FIND SIMILAR
+  // -------------------------------------------------------------------------
+
+  it('find_similar returns related camping memory', async () => {
+    const res = parseResult(await handleFindSimilar(
+      { memory_id: memoryId, limit: 5, min_similarity: 0.3 },
+      userId, auth,
+    ));
+
+    expect(res.similar_memories).toBeDefined();
+    expect(res.similar_memories.length).toBeGreaterThan(0);
+    // The gear memory should be more similar than the cookie recipe
+    const ids = res.similar_memories.map((m: any) => m.id);
+    expect(ids).toContain(secondMemoryId);
+    console.log(`  find_similar returned ${res.similar_memories.length} results`);
+  });
+
+  // -------------------------------------------------------------------------
+  // QUERY (RAG / semantic)
+  // -------------------------------------------------------------------------
+
+  it('query_memory returns relevant results for natural language question', async () => {
+    const res = parseResult(await handleQueryMemory(
+      { query: 'What outdoor activities have I done recently?', limit: 5, min_relevance: 0.3 },
+      userId, auth,
+    ));
+
+    expect(res.memories).toBeDefined();
+    expect(res.memories.length).toBeGreaterThan(0);
+    console.log(`  query returned ${res.memories.length} memories`);
+  });
+
+  // -------------------------------------------------------------------------
+  // DELETE (soft delete + confirm)
+  // -------------------------------------------------------------------------
+
+  it('requests deletion and gets a token', async () => {
+    const res = parseResult(await handleDeleteMemory(
+      { memory_id: thirdMemoryId, reason: 'e2e cleanup' },
+      userId, auth,
+    ));
+
+    expect(res.success).toBe(true);
+    expect(res.token).toBeTruthy();
+
+    // Confirm the deletion
+    const confirmRes = parseResult(await handleConfirm(
+      { token: res.token },
+      userId, auth,
+    ));
+    expect(confirmRes.success).toBe(true);
+    expect(confirmRes.memory_id).toBe(thirdMemoryId);
+    console.log(`  deleted memory ${thirdMemoryId}`);
+  });
+
+  it('deleted memory is excluded from default search', async () => {
+    await waitForIndex();
+
+    const res = parseResult(await handleSearchMemory(
+      { query: 'chocolate chip cookie recipe', limit: 10 },
+      userId, auth,
+    ));
+
+    const ids = res.memories.map((m: any) => m.id);
+    expect(ids).not.toContain(thirdMemoryId);
+  });
+
+  it('deleted memory is visible with deleted_filter=only', async () => {
+    const res = parseResult(await handleSearchMemory(
+      { query: 'chocolate chip cookie recipe', limit: 10, deleted_filter: 'only' } as any,
+      userId, auth,
+    ));
+
+    const ids = res.memories.map((m: any) => m.id);
+    expect(ids).toContain(thirdMemoryId);
+  });
+});

package/src/preferences.e2e.ts

@@ -0,0 +1,88 @@
+/**
+ * E2E: Preferences — get/set preferences
+ *
+ * Run with:
+ *   DOTENV_CONFIG_PATH=.env.e1.local npm run test:e2e -- --testPathPattern=preferences
+ */
+
+import {
+  e2eInit, e2eUserId, e2eAuthContext, e2eCleanup, parseResult,
+} from './e2e-helpers.js';
+import { handleSetPreference } from './tools/set-preference.js';
+import { handleGetPreferences } from './tools/get-preferences.js';
+
+const userId = e2eUserId('pref');
+const auth = e2eAuthContext();
+
+// BUG: remember-core getUserPreferencesPath returns 3-segment Firestore path
+// ({BASE}.users/{userId}/preferences) which fails validation in firebase-admin-sdk-v8.
+// Fix requires remember-core path update to use 4-segment subcollection paths.
+// These tests WILL FAIL until the core bug is fixed.
+describe('E2E: Preferences', () => {
+  beforeAll(async () => {
+    await e2eInit();
+  }, 30_000);
+
+  afterAll(async () => {
+    await e2eCleanup(userId);
+  }, 30_000);
+
+  it('gets default preferences', async () => {
+    const res = parseResult(await handleGetPreferences(
+      {},
+      userId, auth,
+    ));
+
+    expect(res.preferences).toBeDefined();
+    expect(res.is_default).toBe(true);
+    console.log('  got default preferences');
+  });
+
+  it('sets a search preference', async () => {
+    const res = parseResult(await handleSetPreference(
+      { preferences: { search: { default_limit: 25 } } } as any,
+      userId, auth,
+    ));
+
+    expect(res.success).toBe(true);
+    console.log('  set search.default_limit = 25');
+  });
+
+  it('gets search preferences and sees updated value', async () => {
+    const res = parseResult(await handleGetPreferences(
+      { category: 'search' },
+      userId, auth,
+    ));
+
+    expect(res.preferences).toBeDefined();
+    expect(res.preferences.search.default_limit).toBe(25);
+  });
+
+  it('updates a preference to a new value', async () => {
+    const res = parseResult(await handleSetPreference(
+      { preferences: { search: { default_limit: 50 } } } as any,
+      userId, auth,
+    ));
+    expect(res.success).toBe(true);
+
+    const getRes = parseResult(await handleGetPreferences(
+      { category: 'search' },
+      userId, auth,
+    ));
+    expect(getRes.preferences.search.default_limit).toBe(50);
+  });
+
+  it('sets a display preference', async () => {
+    const res = parseResult(await handleSetPreference(
+      { preferences: { privacy: { default_trust_level: 0.5 } } } as any,
+      userId, auth,
+    ));
+    expect(res.success).toBe(true);
+
+    const getRes = parseResult(await handleGetPreferences(
+      { category: 'privacy' },
+      userId, auth,
+    ));
+    expect(getRes.preferences.privacy.default_trust_level).toBe(0.5);
+  });
+});

package/src/relationships.e2e.ts

@@ -0,0 +1,156 @@
+/**
+ * E2E: Relationships — create/search/update/delete relationships
+ *
+ * Run with:
+ *   DOTENV_CONFIG_PATH=.env.e1.local npm run test:e2e -- --testPathPattern=relationships
+ */
+
+import {
+  e2eInit, e2eUserId, e2eAuthContext, e2eEnsureCollection,
+  e2eCleanup, parseResult, waitForIndex,
+} from './e2e-helpers.js';
+import { handleCreateMemory } from './tools/create-memory.js';
+import { handleCreateRelationship } from './tools/create-relationship.js';
+import { handleSearchRelationship } from './tools/search-relationship.js';
+import { handleUpdateRelationship } from './tools/update-relationship.js';
+import { handleDeleteRelationship } from './tools/delete-relationship.js';
+import { handleSearchMemory } from './tools/search-memory.js';
+
+const userId = e2eUserId('rel');
+const auth = e2eAuthContext();
+
+describe('E2E: Relationships', () => {
+  let memA: string;
+  let memB: string;
+  let relId: string;
+
+  beforeAll(async () => {
+    await e2eInit();
+    await e2eEnsureCollection(userId);
+
+    // Create two memories to link
+    const a = parseResult(await handleCreateMemory(
+      { content: 'Learned TypeScript generics at work today. Mapped types are powerful.', tags: ['typescript', 'learning'] },
+      userId, auth,
+    ));
+    memA = a.memory_id;
+
+    const b = parseResult(await handleCreateMemory(
+      { content: 'Built a type-safe API client using TypeScript generics and Zod validation.', tags: ['typescript', 'api'] },
+      userId, auth,
+    ));
+    memB = b.memory_id;
+
+    await waitForIndex();
+  }, 30_000);
+
+  afterAll(async () => {
+    await e2eCleanup(userId);
+  }, 30_000);
+
+  // -------------------------------------------------------------------------
+  // CREATE RELATIONSHIP
+  // -------------------------------------------------------------------------
+
+  it('creates a relationship linking two memories', async () => {
+    const res = parseResult(await handleCreateRelationship(
+      {
+        memory_ids: [memA, memB],
+        relationship_type: 'applied_learning',
+        observation: 'The TypeScript generics knowledge was directly applied to build the API client.',
+        strength: 0.9,
+      },
+      userId, auth,
+    ));
+
+    expect(res.relationship_id).toBeTruthy();
+    expect(res.memory_ids).toContain(memA);
+    expect(res.memory_ids).toContain(memB);
+    relId = res.relationship_id;
+    console.log(`  created relationship ${relId}`);
+  });
+
+  // -------------------------------------------------------------------------
+  // SEARCH RELATIONSHIP
+  // -------------------------------------------------------------------------
+
+  it('finds relationship via semantic search on observation', async () => {
+    await waitForIndex();
+
+    const res = parseResult(await handleSearchRelationship(
+      { query: 'applied generics knowledge to API', limit: 5 },
+      userId, auth,
+    ));
+
+    expect(res.relationships).toBeDefined();
+    expect(res.relationships.length).toBeGreaterThan(0);
+    const ids = res.relationships.map((r: any) => r.id);
+    expect(ids).toContain(relId);
+  });
+
+  it('search_memory with include_relationships returns both memories and relationships', async () => {
+    const res = parseResult(await handleSearchMemory(
+      { query: 'TypeScript generics', limit: 10, include_relationships: true },
+      userId, auth,
+    ));
+
+    expect(res.memories.length).toBeGreaterThan(0);
+    expect(res.relationships).toBeDefined();
+    expect(res.relationships.length).toBeGreaterThan(0);
+  });
+
+  // -------------------------------------------------------------------------
+  // UPDATE RELATIONSHIP
+  // -------------------------------------------------------------------------
+
+  it('updates the relationship observation', async () => {
+    const res = parseResult(await handleUpdateRelationship(
+      {
+        relationship_id: relId,
+        observation: 'The TypeScript generics knowledge was applied to build a production API client with full type safety.',
+        strength: 1.0,
+      },
+      userId, auth,
+    ));
+
+    expect(res.relationship_id).toBe(relId);
+  });
+
+  it('search reflects updated observation', async () => {
+    await waitForIndex();
+
+    const res = parseResult(await handleSearchRelationship(
+      { query: 'production API client full type safety', limit: 5 },
+      userId, auth,
+    ));
+
+    const found = res.relationships.find((r: any) => r.id === relId);
+    expect(found).toBeTruthy();
+    expect(found.observation).toContain('production');
+  });
+
+  // -------------------------------------------------------------------------
+  // DELETE RELATIONSHIP
+  // -------------------------------------------------------------------------
+
+  it('deletes the relationship', async () => {
+    const res = parseResult(await handleDeleteRelationship(
+      { relationship_id: relId },
+      userId, auth,
+    ));
+
+    expect(res.deleted).toBe(true);
+  });
+
+  it('deleted relationship no longer appears in search', async () => {
+    await waitForIndex();
+
+    const res = parseResult(await handleSearchRelationship(
+      { query: 'TypeScript generics applied learning', limit: 5 },
+      userId, auth,
+    ));
+
+    const ids = (res.relationships || []).map((r: any) => r.id);
+    expect(ids).not.toContain(relId);
+  });
+});

package/src/search-modes.e2e.ts

@@ -0,0 +1,184 @@
+/**
+ * E2E: Advanced Search Modes — search_by and search_space_by
+ *
+ * Run with:
+ *   DOTENV_CONFIG_PATH=.env.e1.local npm run test:e2e -- --testPathPattern=search-modes
+ */
+
+import {
+  e2eInit, e2eUserId, e2eAuthContext, e2eEnsureCollection,
+  e2eCleanup, parseResult, waitForIndex,
+} from './e2e-helpers.js';
+import { handleCreateMemory } from './tools/create-memory.js';
+import { handleSearchBy } from './tools/search-by.js';
+import { handlePublish } from './tools/publish.js';
+import { handleConfirm } from './tools/confirm.js';
+import { handleSearchSpaceBy } from './tools/search-space-by.js';
+
+const userId = e2eUserId('modes');
+const auth = e2eAuthContext();
+const SPACE = 'the_void';
+
+describe('E2E: Search Modes', () => {
+  const memoryIds: string[] = [];
+
+  beforeAll(async () => {
+    await e2eInit();
+    await e2eEnsureCollection(userId);
+
+    // Create several memories with varying weights and tags
+    const memories = [
+      { content: 'Morning run along the river trail, 5 miles in 42 minutes.', weight: 0.5, tags: ['fitness', 'running'] },
+      { content: 'Read "Thinking Fast and Slow" by Kahneman. Chapter on anchoring bias was eye-opening.', weight: 0.9, tags: ['reading', 'psychology'] },
+      { content: 'Cooked pad thai for dinner. Used tamarind paste instead of ketchup this time.', weight: 0.3, tags: ['cooking', 'thai'] },
+      { content: 'Team standup: discussed migration plan for database sharding.', weight: 0.7, tags: ['work', 'database'] },
+      { content: 'Guitar practice: learned the intro to Stairway to Heaven.', weight: 0.6, tags: ['music', 'guitar'] },
+    ];
+
+    for (const mem of memories) {
+      const res = parseResult(await handleCreateMemory(mem, userId, auth));
+      memoryIds.push(res.memory_id);
+    }
+
+    // Publish one to space for search_space_by tests
+    const pubRes = parseResult(await handlePublish(
+      { memory_id: memoryIds[1], spaces: [SPACE] },
+      userId, auth,
+    ));
+    const confirmRes = parseResult(await handleConfirm(
+      { token: pubRes.token },
+      userId, auth,
+    ));
+
+    await waitForIndex(2000);
+  }, 60_000);
+
+  afterAll(async () => {
+    await e2eCleanup(userId);
+  }, 30_000);
+
+  // -------------------------------------------------------------------------
+  // search_by modes
+  // -------------------------------------------------------------------------
+
+  describe('search_by', () => {
+    it('byTime returns memories in chronological order', async () => {
+      const res = parseResult(await handleSearchBy(
+        { mode: 'byTime', sort_order: 'desc', limit: 5 },
+        userId, auth,
+      ));
+
+      expect(res.memories).toBeDefined();
+      expect(res.memories.length).toBe(5);
+      // Should be newest first
+      const dates = res.memories.map((m: any) => new Date(m.created_at).getTime());
+      for (let i = 0; i < dates.length - 1; i++) {
+        expect(dates[i]).toBeGreaterThanOrEqual(dates[i + 1]);
+      }
+      console.log(`  byTime returned ${res.memories.length} memories`);
+    });
+
+    it('byTime ascending returns oldest first', async () => {
+      const res = parseResult(await handleSearchBy(
+        { mode: 'byTime', sort_order: 'asc', limit: 5 },
+        userId, auth,
+      ));
+
+      const dates = res.memories.map((m: any) => new Date(m.created_at).getTime());
+      for (let i = 0; i < dates.length - 1; i++) {
+        expect(dates[i]).toBeLessThanOrEqual(dates[i + 1]);
+      }
+    });
+
+    it('byBroad returns truncated content for scanning', async () => {
+      const res = parseResult(await handleSearchBy(
+        { mode: 'byBroad', limit: 10 },
+        userId, auth,
+      ));
+
+      // byBroad returns { results: [...] } not { memories: [...] }
+      expect(res.results).toBeDefined();
+      expect(res.results.length).toBeGreaterThan(0);
+      // Verify truncated content fields exist
+      const first = res.results[0];
+      expect(first.content_head).toBeDefined();
+      console.log(`  byBroad returned ${res.results.length} results`);
+    });
+
+    it('byRandom returns results', async () => {
+      const res = parseResult(await handleSearchBy(
+        { mode: 'byRandom', limit: 3 },
+        userId, auth,
+      ));
+
+      // byRandom returns { results: [...], total_pool_size }
+      expect(res.results).toBeDefined();
+      expect(res.results.length).toBeGreaterThan(0);
+      expect(res.results.length).toBeLessThanOrEqual(3);
+    });
+
+    it('byProperty sorts by weight', async () => {
+      const res = parseResult(await handleSearchBy(
+        { mode: 'byProperty', sort_field: 'weight', sort_order: 'desc', limit: 5 },
+        userId, auth,
+      ));
+
+      expect(res.memories).toBeDefined();
+      expect(res.memories.length).toBeGreaterThan(0);
+      // Highest weight memory (0.9 — the reading one) should be first
+      const weights = res.memories.map((m: any) => m.weight);
+      for (let i = 0; i < weights.length - 1; i++) {
+        expect(weights[i]).toBeGreaterThanOrEqual(weights[i + 1]);
+      }
+    });
+
+    it('byDensity returns results (may be 0 if no relationships)', async () => {
+      const res = parseResult(await handleSearchBy(
+        { mode: 'byDensity', limit: 5 },
+        userId, auth,
+      ));
+
+      expect(res.memories).toBeDefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // search_space_by modes
+  // -------------------------------------------------------------------------
+
+  // BUG: Most search_space_by modes are unimplemented in remember-core's SpaceService.
+  // byTime, byRating, byProperty, byBroad, byRandom all return hardcoded error strings.
+  // Fix: implement these modes in SpaceService, mirroring MemoryService equivalents.
+  // These tests WILL FAIL until the core methods are implemented.
+  describe('search_space_by', () => {
+    it('byTime returns space memories chronologically', async () => {
+      const res = parseResult(await handleSearchSpaceBy(
+        { mode: 'byTime', spaces: [SPACE], sort_order: 'desc', limit: 5 },
+        userId, auth,
+      ));
+
+      expect(res.memories).toBeDefined();
+      expect(res.memories.length).toBeGreaterThan(0);
+    });
+
+    it('byBroad returns space memories with truncated content', async () => {
+      const res = parseResult(await handleSearchSpaceBy(
+        { mode: 'byBroad', spaces: [SPACE], limit: 10 },
+        userId, auth,
+      ));
+
+      expect(res.results).toBeDefined();
+      expect(res.results.length).toBeGreaterThan(0);
+    });
+
+    it('byRandom returns space memories', async () => {
+      const res = parseResult(await handleSearchSpaceBy(
+        { mode: 'byRandom', spaces: [SPACE], limit: 3 },
+        userId, auth,
+      ));
+
+      expect(res.results).toBeDefined();
+      expect(res.results.length).toBeGreaterThan(0);
+    });
+  });
+});