@prmichaelsen/remember-mcp 3.13.0 → 3.14.1

package/src/tools/find-similar.ts

@@ -4,12 +4,10 @@
  */
 
 import type { Memory, DeletedFilter } from '../types/memory.js';
-import { getMemoryCollection } from '../weaviate/schema.js';
-import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
-import { buildDeletedFilter, combineFiltersWithAnd } from '../utils/weaviate-filters.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_find_similar
@@ -111,122 +109,30 @@ export async function handleFindSimilar(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    logger.info('Finding similar memories', { userId, memoryId: args.memory_id, hasText: !!args.text });
 
-    // Validate input
-    if (!args.memory_id && !args.text) {
-      throw new Error('Either memory_id or text must be provided');
-    }
-
-    if (args.memory_id && args.text) {
-      throw new Error('Provide either memory_id or text, not both');
-    }
-
-    const collection = getMemoryCollection(userId);
-    const limit = args.limit ?? 10;
-    const minSimilarity = args.min_similarity ?? 0.7;
-
-    // Build deleted filter
-    const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || 'exclude');
-
-    // Exclude ghost memories by default
-    const ghostExclusionFilter = collection.filter.byProperty('content_type').notEqual('ghost');
-
-    // Combine filters
-    const baseFilter = combineFiltersWithAnd([deletedFilter, ghostExclusionFilter].filter(f => f !== null));
-
-    let results: any;
-
-    if (args.memory_id) {
-      // Find similar to existing memory
-      // First get the memory to verify ownership
-      const memory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ['user_id', 'doc_type', 'content'],
-      });
-
-      if (!memory) {
-        throw new Error(`Memory not found: ${args.memory_id}`);
-      }
-
-      // Verify ownership
-      if (memory.properties.user_id !== userId) {
-        throw new Error('Unauthorized: Cannot access another user\'s memory');
-      }
-
-      // Verify it's a memory
-      if (memory.properties.doc_type !== 'memory') {
-        throw new Error('Can only find similar memories for memory documents, not relationships');
-      }
-
-      // Find similar using nearObject
-      const searchOptions: any = {
-        limit: limit + 1, // +1 to exclude the source memory itself
-        distance: 1 - minSimilarity, // Convert similarity to distance
-        returnMetadata: ['distance'],
-      };
-
-      // Add filters if present
-      if (baseFilter) {
-        searchOptions.filters = baseFilter;
-      }
-
-      results = await collection.query.nearObject(args.memory_id, searchOptions);
-
-      // Filter out the source memory
-      results.objects = results.objects.filter((obj: any) => obj.uuid !== args.memory_id);
-    } else {
-      // Find similar to text
-      const searchOptions: any = {
-        limit: limit,
-        distance: 1 - minSimilarity,
-        returnMetadata: ['distance'],
-      };
-
-      // Add filters if present
-      if (baseFilter) {
-        searchOptions.filters = baseFilter;
-      }
-
-      results = await collection.query.nearText(args.text!, searchOptions);
-    }
-
-    // Filter to only memories (not relationships) unless requested
-    if (!args.include_relationships) {
-      results.objects = results.objects.filter(
-        (obj: any) => obj.properties.doc_type === 'memory'
-      );
-    }
-
-    // Format results with similarity scores
-    const similarMemories: SimilarMemory[] = results.objects.map((obj: any) => {
-      const similarity = 1 - (obj.metadata?.distance ?? 0); // Convert distance back to similarity
-      return {
-        id: obj.uuid,
-        ...obj.properties,
-        similarity: Math.max(0, Math.min(1, similarity)), // Clamp to [0, 1]
-      };
+    const { memory } = createCoreServices(userId);
+    const coreResult = await memory.findSimilar({
+      memory_id: args.memory_id,
+      text: args.text,
+      limit: args.limit,
+      min_similarity: args.min_similarity,
+      include_relationships: args.include_relationships,
+      deleted_filter: args.deleted_filter,
     });
 
-    // Sort by similarity (highest first)
-    similarMemories.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
-
-    // Limit results
-    const limitedResults = similarMemories.slice(0, limit);
-
-    logger.info('Similar memories found', {
-      userId,
-      query: args.memory_id || args.text,
-      results: limitedResults.length,
-    });
+    // Post-filter ghost content (core doesn't exclude ghosts)
+    const filteredMemories = coreResult.similar_memories.filter(
+      (m: any) => m.content_type !== 'ghost'
+    );
 
     const result: FindSimilarResult = {
       query: {
         memory_id: args.memory_id,
         text: args.text,
       },
-      similar_memories: limitedResults,
-      total: limitedResults.length,
-      min_similarity: minSimilarity,
+      similar_memories: filteredMemories as unknown as SimilarMemory[],
+      total: filteredMemories.length,
+      min_similarity: args.min_similarity ?? 0.7,
     };
 
     return JSON.stringify(result, null, 2);

package/src/tools/get-preferences.ts

@@ -3,8 +3,6 @@
  * Retrieve user preferences with defaults
  */
 
-import { PreferencesDatabaseService } from '../services/preferences-database.service.js';
-import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import {
@@ -14,6 +12,7 @@ import {
   getPreferenceDescription,
 } from '../types/preferences.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_get_preferences
@@ -74,10 +73,8 @@ export async function handleGetPreferences(
 
     const { category } = args;
 
-    logger.info('Getting preferences', { userId, category });
-
-    // Get preferences using service layer
-    const preferences = await PreferencesDatabaseService.getPreferences(userId);
+    const { preferences: preferencesService } = createCoreServices(userId);
+    const preferences = await preferencesService.getPreferences(userId);
 
     // Check if these are defaults (no created_at means they were just generated)
     const isDefault = !preferences.created_at || preferences.created_at === preferences.updated_at;
@@ -110,8 +107,6 @@ export async function handleGetPreferences(
       message,
     };
 
-    logger.info('Preferences retrieved successfully', { userId, category, isDefault });
-
     return JSON.stringify(response, null, 2);
   } catch (error) {
     debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });

package/src/tools/moderate.spec.ts

@@ -7,25 +7,8 @@ import type { AuthContext, GroupPermissions } from '../types/auth.js';
 
 // ─── Mocks ───────────────────────────────────────────────────
 
-const mockUpdate = jest.fn().mockResolvedValue(undefined);
-
-jest.mock('../weaviate/client.js', () => ({
-  getWeaviateClient: jest.fn(() => ({
-    collections: {
-      get: jest.fn().mockReturnValue({
-        data: { update: jest.fn().mockResolvedValue(undefined) },
-      }),
-    },
-  })),
-  fetchMemoryWithAllProperties: jest.fn(),
-}));
-
-jest.mock('../weaviate/space-schema.js', () => ({
-  ensurePublicCollection: jest.fn(),
-}));
-
-jest.mock('../utils/logger.js', () => ({
-  logger: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+jest.mock('../core-services.js', () => ({
+  createCoreServices: jest.fn(),
 }));
 
 jest.mock('../utils/debug.js', () => ({
@@ -38,21 +21,12 @@ jest.mock('../utils/debug.js', () => ({
   })),
 }));
 
-jest.mock('../collections/dot-notation.js', () => ({
-  CollectionType: { GROUPS: 'groups' },
-  getCollectionName: jest.fn((_: string, id: string) => `Memory_groups_${id}`),
-}));
-
 jest.mock('../utils/error-handler.js', () => ({
   handleToolError: jest.fn(() => '{"success":false,"error":"internal"}'),
 }));
 
-import { getWeaviateClient, fetchMemoryWithAllProperties } from '../weaviate/client.js';
-import { ensurePublicCollection } from '../weaviate/space-schema.js';
-
-const mockFetchMemory = fetchMemoryWithAllProperties as jest.MockedFunction<any>;
-const mockGetWeaviateClient = getWeaviateClient as jest.MockedFunction<any>;
-const mockEnsurePublicCollection = ensurePublicCollection as jest.MockedFunction<any>;
+import { createCoreServices } from '../core-services.js';
+const mockCreateCoreServices = createCoreServices as jest.MockedFunction<any>;
 
 // ─── Helpers ─────────────────────────────────────────────────
 
@@ -95,14 +69,6 @@ function makeNonModeratorAuth(): AuthContext {
   };
 }
 
-const PUBLISHED_MEMORY = {
-  properties: {
-    content: 'Published memory',
-    moderation_status: 'pending',
-    author_id: 'author-1',
-  },
-};
-
 // ─── Tests ───────────────────────────────────────────────────
 
 describe('moderateTool definition', () => {
@@ -121,39 +87,28 @@ describe('moderateTool definition', () => {
 });
 
 describe('handleModerate', () => {
-  let groupUpdate: jest.Mock;
-  let spaceUpdate: jest.Mock;
+  let mockModerate: jest.Mock;
 
   beforeEach(() => {
     jest.clearAllMocks();
-
-    groupUpdate = jest.fn().mockResolvedValue(undefined);
-    spaceUpdate = jest.fn().mockResolvedValue(undefined);
-
-    mockGetWeaviateClient.mockReturnValue({
-      collections: {
-        get: jest.fn().mockReturnValue({
-          data: { update: groupUpdate },
-        }),
-      },
-    });
-
-    mockEnsurePublicCollection.mockResolvedValue({
-      data: { update: spaceUpdate },
+    mockModerate = jest.fn();
+    mockCreateCoreServices.mockReturnValue({
+      space: { moderate: mockModerate },
     });
-
-    mockFetchMemory.mockResolvedValue(PUBLISHED_MEMORY);
   });
 
-  it('returns error when no space_id or group_id provided', async () => {
+  it('returns error when core throws for missing destination', async () => {
+    mockModerate.mockRejectedValue(new Error('Must specify either space_id or group_id'));
+
     const result = JSON.parse(
       await handleModerate({ memory_id: 'mem-1', action: 'approve' }, 'mod-1', makeModeratorAuth('g1'))
     );
     expect(result.success).toBe(false);
-    expect(result.error).toBe('Missing destination');
   });
 
-  it('returns permission error for non-moderator on group', async () => {
+  it('returns error when core throws for non-moderator on group', async () => {
+    mockModerate.mockRejectedValue(new Error('Permission denied'));
+
     const result = JSON.parse(
       await handleModerate(
         { memory_id: 'mem-1', action: 'approve', group_id: 'team-1' },
@@ -162,10 +117,11 @@ describe('handleModerate', () => {
       )
     );
     expect(result.success).toBe(false);
-    expect(result.error).toBe('Permission denied');
   });
 
-  it('returns permission error for non-moderator on space', async () => {
+  it('returns error when core throws for non-moderator on space', async () => {
+    mockModerate.mockRejectedValue(new Error('Permission denied'));
+
     const result = JSON.parse(
       await handleModerate(
         { memory_id: 'mem-1', action: 'approve', space_id: 'public' },
@@ -174,11 +130,10 @@ describe('handleModerate', () => {
       )
     );
     expect(result.success).toBe(false);
-    expect(result.error).toBe('Permission denied');
   });
 
-  it('returns error when memory not found', async () => {
-    mockFetchMemory.mockResolvedValue(null);
+  it('returns error when core throws for memory not found', async () => {
+    mockModerate.mockRejectedValue(new Error('Memory not found'));
 
     const result = JSON.parse(
       await handleModerate(
@@ -188,10 +143,18 @@ describe('handleModerate', () => {
       )
     );
     expect(result.success).toBe(false);
-    expect(result.error).toBe('Memory not found');
   });
 
   it('approves a memory in a group', async () => {
+    mockModerate.mockResolvedValue({
+      memory_id: 'mem-1',
+      action: 'approve',
+      moderation_status: 'approved',
+      moderated_by: 'mod-1',
+      moderated_at: new Date().toISOString(),
+      location: 'group:g1',
+    });
+
     const result = JSON.parse(
       await handleModerate(
         { memory_id: 'mem-1', action: 'approve', group_id: 'g1' },
@@ -203,17 +166,18 @@ describe('handleModerate', () => {
     expect(result.moderation_status).toBe('approved');
     expect(result.moderated_by).toBe('mod-1');
     expect(result.moderated_at).toBeDefined();
-
-    expect(groupUpdate).toHaveBeenCalledWith({
-      id: 'mem-1',
-      properties: expect.objectContaining({
-        moderation_status: 'approved',
-        moderated_by: 'mod-1',
-      }),
-    });
   });
 
   it('rejects a memory in a group', async () => {
+    mockModerate.mockResolvedValue({
+      memory_id: 'mem-1',
+      action: 'reject',
+      moderation_status: 'rejected',
+      moderated_by: 'mod-1',
+      moderated_at: new Date().toISOString(),
+      location: 'group:g1',
+    });
+
     const result = JSON.parse(
       await handleModerate(
         { memory_id: 'mem-1', action: 'reject', group_id: 'g1', reason: 'Spam' },
@@ -227,6 +191,15 @@ describe('handleModerate', () => {
   });
 
   it('removes a memory in a group', async () => {
+    mockModerate.mockResolvedValue({
+      memory_id: 'mem-1',
+      action: 'remove',
+      moderation_status: 'removed',
+      moderated_by: 'mod-1',
+      moderated_at: new Date().toISOString(),
+      location: 'group:g1',
+    });
+
     const result = JSON.parse(
       await handleModerate(
         { memory_id: 'mem-1', action: 'remove', group_id: 'g1' },
@@ -239,6 +212,15 @@ describe('handleModerate', () => {
   });
 
   it('moderates a memory in a space', async () => {
+    mockModerate.mockResolvedValue({
+      memory_id: 'mem-1',
+      action: 'approve',
+      moderation_status: 'approved',
+      moderated_by: 'mod-1',
+      moderated_at: new Date().toISOString(),
+      location: 'space:public',
+    });
+
     const result = JSON.parse(
       await handleModerate(
         { memory_id: 'mem-1', action: 'approve', space_id: 'public' },
@@ -249,18 +231,20 @@ describe('handleModerate', () => {
     expect(result.success).toBe(true);
     expect(result.moderation_status).toBe('approved');
     expect(result.location).toBe('space:public');
-
-    expect(spaceUpdate).toHaveBeenCalledWith({
-      id: 'mem-1',
-      properties: expect.objectContaining({
-        moderation_status: 'approved',
-        moderated_by: 'mod-1',
-      }),
-    });
   });
 
   it('sets moderated_at to a valid ISO date', async () => {
     const before = new Date().toISOString();
+    const moderatedAt = new Date().toISOString();
+
+    mockModerate.mockResolvedValue({
+      memory_id: 'mem-1',
+      action: 'approve',
+      moderation_status: 'approved',
+      moderated_by: 'mod-1',
+      moderated_at: moderatedAt,
+      location: 'group:g1',
+    });
 
     const result = JSON.parse(
       await handleModerate(

package/src/tools/moderate.ts

@@ -6,23 +6,13 @@
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { getWeaviateClient, fetchMemoryWithAllProperties } from '../weaviate/client.js';
-import { ensurePublicCollection } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
-import { logger } from '../utils/logger.js';
-import { CollectionType, getCollectionName } from '../collections/dot-notation.js';
 import type { AuthContext } from '../types/auth.js';
-import { canModerate, canModerateAny } from '../utils/auth-helpers.js';
+import { createCoreServices } from '../core-services.js';
 
 type ModerationAction = 'approve' | 'reject' | 'remove';
 
-const ACTION_TO_STATUS: Record<ModerationAction, string> = {
-  approve: 'approved',
-  reject: 'rejected',
-  remove: 'removed',
-};
-
 export const moderateTool: Tool = {
   name: 'remember_moderate',
   description: `Approve, reject, or remove a published memory. Requires moderator permissions (can_moderate).
@@ -85,121 +75,28 @@ export async function handleModerate(
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
 
-    const { memory_id, space_id, group_id, action, reason } = args;
-
-    // Validate: must specify either space_id or group_id
-    if (!space_id && !group_id) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Missing destination',
-          message: 'Must specify either space_id or group_id',
-        },
-        null,
-        2
-      );
-    }
-
-    // Validate action
-    if (!ACTION_TO_STATUS[action]) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Invalid action',
-          message: `Action must be one of: approve, reject, remove`,
-        },
-        null,
-        2
-      );
-    }
-
-    // Permission check
-    if (group_id) {
-      if (!canModerate(authContext, group_id)) {
-        return JSON.stringify(
-          {
-            success: false,
-            error: 'Permission denied',
-            message: `Moderator access required for group ${group_id}`,
-          },
-          null,
-          2
-        );
-      }
-    } else if (space_id) {
-      if (!canModerateAny(authContext)) {
-        return JSON.stringify(
-          {
-            success: false,
-            error: 'Permission denied',
-            message: `Moderator access required to moderate memories in spaces`,
-          },
-          null,
-          2
-        );
-      }
-    }
-
-    // Get the collection
-    const weaviateClient = getWeaviateClient();
-    let collection: any;
-
-    if (group_id) {
-      const collectionName = getCollectionName(CollectionType.GROUPS, group_id);
-      collection = weaviateClient.collections.get(collectionName);
-    } else {
-      collection = await ensurePublicCollection(weaviateClient);
-    }
-
-    // Fetch the memory
-    const memory = await fetchMemoryWithAllProperties(collection, memory_id);
-
-    if (!memory) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Memory not found',
-          message: `Published memory ${memory_id} not found in ${group_id ? `group ${group_id}` : `space ${space_id}`}`,
-        },
-        null,
-        2
-      );
-    }
-
-    // Update moderation fields
-    const newStatus = ACTION_TO_STATUS[action];
-    const now = new Date().toISOString();
-
-    await collection.data.update({
-      id: memory_id,
-      properties: {
-        moderation_status: newStatus,
-        moderated_by: userId,
-        moderated_at: now,
+    const { space } = createCoreServices(userId);
+    const result = await space.moderate(
+      {
+        memory_id: args.memory_id,
+        space_id: args.space_id,
+        group_id: args.group_id,
+        action: args.action as any,
+        reason: args.reason,
       },
-    });
-
-    logger.info('Memory moderated', {
-      tool: 'remember_moderate',
-      userId,
-      memoryId: memory_id,
-      action,
-      newStatus,
-      spaceId: space_id,
-      groupId: group_id,
-      reason,
-    });
+      authContext as any
+    );
 
     return JSON.stringify(
       {
         success: true,
-        memory_id,
-        action,
-        moderation_status: newStatus,
-        moderated_by: userId,
-        moderated_at: now,
-        reason: reason || undefined,
-        location: group_id ? `group:${group_id}` : `space:${space_id}`,
+        memory_id: result.memory_id,
+        action: result.action,
+        moderation_status: result.moderation_status,
+        moderated_by: result.moderated_by,
+        moderated_at: result.moderated_at,
+        reason: args.reason || undefined,
+        location: result.location,
       },
       null,
       2