@prmichaelsen/remember-mcp 3.13.0 → 3.14.1

package/src/tools/publish.ts

@@ -12,14 +12,11 @@
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { confirmationTokenService } from '../services/confirmation-token.service.js';
-import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties } from '../weaviate/client.js';
-import { isValidSpaceId } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
-import { logger } from '../utils/logger.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_publish
@@ -92,213 +89,19 @@ export async function handlePublish(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    
-    // Normalize arrays (handle undefined)
-    const spaces = args.spaces || [];
-    const groups = args.groups || [];
-    
-    logger.info('Starting publish request', {
-      tool: 'remember_publish',
-      userId,
-      memoryId: args.memory_id,
-      spaces,
-      groups,
-      spaceCount: spaces.length,
-      groupCount: groups.length,
-      additionalTags: args.additional_tags?.length || 0,
-    });
-    
-    // Validate that at least one destination is provided
-    if (spaces.length === 0 && groups.length === 0) {
-      logger.warn('No destinations provided', {
-        tool: 'remember_publish',
-        userId,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'No destinations provided',
-          message: 'Must specify at least one space or group to publish to',
-        },
-        null,
-        2
-      );
-    }
-    
-    // Validate all space IDs
-    if (spaces.length > 0) {
-      debug.debug('Validating space IDs', { spaces });
-      const invalidSpaces = spaces.filter(s => !isValidSpaceId(s));
-      if (invalidSpaces.length > 0) {
-        debug.warn('Invalid space IDs detected', { invalidSpaces });
-        logger.warn('Invalid space IDs provided', {
-          tool: 'remember_publish',
-          invalidSpaces,
-          providedSpaces: spaces,
-        });
-        return JSON.stringify(
-          {
-            success: false,
-            error: 'Invalid space IDs',
-            message: `Invalid spaces: ${invalidSpaces.join(', ')}. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
-            context: {
-              invalid_spaces: invalidSpaces,
-              provided_spaces: spaces,
-              supported_spaces: SUPPORTED_SPACES,
-            },
-          },
-          null,
-          2
-        );
-      }
-    }
-    
-    // Validate group IDs format (basic validation - no dots allowed)
-    if (groups.length > 0) {
-      debug.debug('Validating group IDs', { groups });
-      const invalidGroups = groups.filter(g => !g || g.includes('.') || g.trim() === '');
-      if (invalidGroups.length > 0) {
-        debug.warn('Invalid group IDs detected', { invalidGroups });
-        logger.warn('Invalid group IDs provided', {
-          tool: 'remember_publish',
-          invalidGroups,
-          providedGroups: groups,
-        });
-        return JSON.stringify(
-          {
-            success: false,
-            error: 'Invalid group IDs',
-            message: 'Group IDs cannot be empty or contain dots',
-            context: {
-              invalid_groups: invalidGroups,
-              provided_groups: groups,
-            },
-          },
-          null,
-          2
-        );
-      }
-    }
-
-    // Verify memory exists and user owns it
-    const weaviateClient = getWeaviateClient();
-    const collectionName = getMemoryCollectionName(userId);
-    logger.debug('Fetching memory from collection', {
-      tool: 'remember_publish',
-      collectionName,
-      memoryId: args.memory_id,
-    });
-    
-    const userCollection = weaviateClient.collections.get(collectionName);
-
-    const memory = await debug.time('Fetch memory from user collection', async () => {
-      return await fetchMemoryWithAllProperties(userCollection, args.memory_id);
-    });
-    
-    logger.debug('Memory fetch result', {
-      tool: 'remember_publish',
-      found: !!memory,
-      memoryId: args.memory_id,
-      hasProperties: !!memory?.properties,
-      propertyCount: memory?.properties ? Object.keys(memory.properties).length : 0,
-      hasTitle: !!memory?.properties?.title,
-      hasContent: !!memory?.properties?.content,
-    });
-
-    if (!memory) {
-      logger.info('Memory not found', {
-        tool: 'remember_publish',
-        memoryId: args.memory_id,
-        collectionName,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Memory not found',
-          message: `No memory found with ID: ${args.memory_id}`,
-          context: {
-            collection_name: getMemoryCollectionName(userId),
-            memory_id: args.memory_id,
-          },
-        },
-        null,
-        2
-      );
-    }
 
-    // Verify ownership
-    if (memory.properties.user_id !== userId) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Permission denied',
-          message: 'You can only publish your own memories',
-          context: {
-            memory_id: args.memory_id,
-            memory_owner: memory.properties.user_id,
-            requesting_user: userId,
-          },
-        },
-        null,
-        2
-      );
-    }
-
-    // Verify it's a memory (not a relationship)
-    if (memory.properties.doc_type !== 'memory') {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Invalid document type',
-          message: 'Only memories can be published (not relationships)',
-          context: {
-            memory_id: args.memory_id,
-            doc_type: memory.properties.doc_type,
-          },
-        },
-        null,
-        2
-      );
-    }
-
-    // Create payload with memory_id, spaces, and groups arrays
-    const payload = {
+    const { space } = createCoreServices(userId);
+    const result = await space.publish({
       memory_id: args.memory_id,
-      spaces: spaces,
-      groups: groups,
-      additional_tags: args.additional_tags || [],
-    };
-
-    logger.info('Generating confirmation token', {
-      tool: 'remember_publish',
-      userId,
-      memoryId: args.memory_id,
-      spaces: spaces,
-      groups: groups,
-    });
-    
-    // Generate confirmation token
-    const { requestId, token} = await confirmationTokenService.createRequest(
-      userId,
-      'publish_memory',
-      payload,
-      undefined  // No single target_collection anymore
-    );
-    
-    logger.info('Confirmation token generated', {
-      tool: 'remember_publish',
-      requestId,
-      token,
-      action: 'publish_memory',
-      spaces: spaces,
-      groups: groups,
+      spaces: args.spaces,
+      groups: args.groups,
+      additional_tags: args.additional_tags,
     });
 
-    // Return minimal response - agent already knows memory details
     return JSON.stringify(
       {
         success: true,
-        token,
+        token: result.token,
       },
       null,
       2

package/src/tools/query-space.ts

@@ -6,16 +6,13 @@
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { Filters } from 'weaviate-client';
-import { getWeaviateClient } from '../weaviate/client.js';
-import { ensurePublicCollection, isValidSpaceId } from '../weaviate/space-schema.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
-import type { ModerationFilter } from './search-space.js';
-import { buildModerationFilter } from './search-space.js';
-import { canModerateAny } from '../utils/auth-helpers.js';
+import { createCoreServices } from '../core-services.js';
+
+export type ModerationFilter = 'approved' | 'pending' | 'rejected' | 'removed' | 'all';
 
 /**
  * Tool definition for remember_query_space
@@ -128,164 +125,55 @@ export async function handleQuerySpace(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    
-    // Validate all space IDs
-    debug.debug('Validating space IDs', { spaces: args.spaces });
-    const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
-    if (invalidSpaces.length > 0) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Invalid space IDs',
-          message: `Invalid spaces: ${invalidSpaces.join(', ')}. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
-        },
-        null,
-        2
-      );
-    }
-    
-    // Validate not empty
-    if (args.spaces.length === 0) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Empty spaces array',
-          message: 'Must specify at least one space to query',
-        },
-        null,
-        2
-      );
-    }
-
-    // Permission check: non-approved moderation filters require moderator access
-    const moderationFilterValue = args.moderation_filter || 'approved';
-    if (moderationFilterValue !== 'approved' && !canModerateAny(authContext)) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Permission denied',
-          message: `Moderator access required to view ${moderationFilterValue} memories in spaces`,
-        },
-        null,
-        2
-      );
-    }
-
-    const weaviateClient = getWeaviateClient();
-    const publicCollection = await ensurePublicCollection(weaviateClient);
-
-    // Build filters
-    const filterList: any[] = [];
 
-    // Filter by spaces array (memory must be in at least one requested space)
-    filterList.push(publicCollection.filter.byProperty('spaces').containsAny(args.spaces));
-
-    // Filter by doc_type (memory) - space_memory concept was removed
-    filterList.push(publicCollection.filter.byProperty('doc_type').equal('memory'));
-
-    // Moderation status filter
-    const moderationFilter = buildModerationFilter(publicCollection, args.moderation_filter);
-    if (moderationFilter) {
-      filterList.push(moderationFilter);
-    }
-
-    // Apply content type filter
-    if (args.content_type) {
-      filterList.push(publicCollection.filter.byProperty('content_type').equal(args.content_type));
-    }
-
-    // Exclude comments and ghost memories by default (unless explicitly included)
-    if (!args.include_comments && !args.content_type) {
-      // Only exclude comments if not filtering by content_type
-      // (if content_type is set, user has explicit control)
-      filterList.push(publicCollection.filter.byProperty('content_type').notEqual('comment'));
-    }
-    if (!args.content_type) {
-      filterList.push(publicCollection.filter.byProperty('content_type').notEqual('ghost'));
-    }
-
-    // Apply tags filter
-    if (args.tags && args.tags.length > 0) {
-      args.tags.forEach(tag => {
-        filterList.push(publicCollection.filter.byProperty('tags').containsAny([tag]));
-      });
-    }
-
-    // Apply weight filter
-    if (args.min_weight !== undefined) {
-      filterList.push(publicCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
-    }
-
-    // Apply date filters
-    if (args.date_from) {
-      filterList.push(publicCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
-    }
-
-    if (args.date_to) {
-      filterList.push(publicCollection.filter.byProperty('created_at').lessOrEqual(new Date(args.date_to)));
-    }
-
-    const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
-
-    debug.debug('Executing semantic query', {
-      question: args.question,
-      filterCount: filterList.length,
-      limit: args.limit || 10,
-    });
-
-    // Execute semantic search using nearText
-    const searchResults = await debug.time('Semantic query', async () => {
-      return await publicCollection.query.nearText(args.question, {
-        limit: args.limit || 10,
-        ...(whereFilter && { where: whereFilter }),
-      });
-    });
-    
-    debug.debug('Query completed', {
-      resultCount: searchResults.objects.length,
-      format: args.format || 'detailed',
-    });
+    const { space } = createCoreServices(userId);
+    const coreResult = await space.query(
+      {
+        question: args.question,
+        spaces: args.spaces,
+        content_type: args.content_type,
+        tags: args.tags,
+        min_weight: args.min_weight,
+        date_from: args.date_from,
+        date_to: args.date_to,
+        moderation_filter: args.moderation_filter as any,
+        include_comments: args.include_comments,
+        limit: args.limit,
+      },
+      authContext as any
+    );
 
     // Format results based on requested format
     const format = args.format || 'detailed';
 
     if (format === 'compact') {
-      // Compact format: text summary for LLM context
-      const summaries = searchResults.objects.map((obj: any, idx: number) => {
-        const props = obj.properties;
-        return `${idx + 1}. ${props.title || props.content?.substring(0, 100) || 'Untitled'}`;
+      const summaries = coreResult.memories.map((mem: any, idx: number) => {
+        return `${idx + 1}. ${mem.title || mem.content?.substring(0, 100) || 'Untitled'}`;
       });
 
       const result = {
         question: args.question,
-        spaces_queried: args.spaces,
+        spaces_queried: coreResult.spaces_queried,
         format: 'compact',
         summary: summaries.join('\n'),
-        count: searchResults.objects.length,
+        count: coreResult.memories.length,
       };
 
       return JSON.stringify(result, null, 2);
     } else {
-      // Detailed format: full objects
-      const memories = searchResults.objects.map((obj: any) => ({
-        id: obj.uuid,
-        ...obj.properties,
-        _distance: obj.metadata?.distance,
-      }));
-
       const result = {
         question: args.question,
-        spaces_queried: args.spaces,
+        spaces_queried: coreResult.spaces_queried,
         format: 'detailed',
-        memories,
-        total: memories.length,
+        memories: coreResult.memories,
+        total: coreResult.total,
       };
 
       debug.info('Tool completed successfully', {
-        resultCount: memories.length,
+        resultCount: coreResult.total,
         format: 'detailed',
       });
-      
+
       return JSON.stringify(result, null, 2);
     }
   } catch (error) {

package/src/tools/retract.ts

@@ -12,12 +12,10 @@
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { confirmationTokenService } from '../services/confirmation-token.service.js';
-import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties } from '../weaviate/client.js';
 import { handleToolError } from '../utils/error-handler.js';
-import { logger } from '../utils/logger.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_retract
@@ -83,195 +81,19 @@ export async function handleRetract(
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
 
-    // Normalize arrays (handle undefined)
-    const spaces = args.spaces || [];
-    const groups = args.groups || [];
-
-    logger.info('Starting retract request', {
-      tool: 'remember_retract',
-      userId,
-      memoryId: args.memory_id,
-      spaces,
-      groups,
-      spaceCount: spaces.length,
-      groupCount: groups.length,
+    const { space } = createCoreServices(userId);
+    const result = await space.retract({
+      memory_id: args.memory_id,
+      spaces: args.spaces,
+      groups: args.groups,
     });
 
-    // Validate that at least one destination is provided
-    if (spaces.length === 0 && groups.length === 0) {
-      logger.warn('No destinations provided for retraction', {
-        tool: 'remember_retract',
-        userId,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'No destinations provided',
-          message: 'Must specify at least one space or group to retract from',
-        },
-        null,
-        2
-      );
-    }
-
-    // Validate group IDs (no dots allowed)
-    if (groups.length > 0) {
-      const invalidGroups = groups.filter(g => g.includes('.'));
-      if (invalidGroups.length > 0) {
-        logger.warn('Invalid group IDs detected', {
-          tool: 'remember_retract',
-          invalidGroups,
-        });
-        return JSON.stringify(
-          {
-            success: false,
-            error: 'Invalid group IDs',
-            message: `Group IDs cannot contain dots: ${invalidGroups.join(', ')}`,
-            context: {
-              invalid_groups: invalidGroups,
-            },
-          },
-          null,
-          2
-        );
-      }
-    }
-
-    // Verify the memory exists and belongs to the user
-    const weaviateClient = getWeaviateClient();
-    const collectionName = getMemoryCollectionName(userId);
-    const collection = weaviateClient.collections.get(collectionName);
-
-    logger.debug('Fetching memory for retraction', {
-      tool: 'remember_retract',
-      collectionName,
-      memoryId: args.memory_id,
-    });
-
-    const memory = await fetchMemoryWithAllProperties(collection, args.memory_id);
-
-    if (!memory) {
-      logger.info('Memory not found for retraction', {
-        tool: 'remember_retract',
-        memoryId: args.memory_id,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Memory not found',
-          message: `Memory ${args.memory_id} does not exist`,
-        },
-        null,
-        2
-      );
-    }
-
-    // Verify ownership
-    if (memory.properties.user_id !== userId) {
-      logger.warn('Permission denied - wrong owner', {
-        tool: 'remember_retract',
-        memoryId: args.memory_id,
-        memoryOwner: memory.properties.user_id,
-        requestingUser: userId,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Permission denied',
-          message: 'You can only retract your own memories',
-        },
-        null,
-        2
-      );
-    }
-
-    // Check current publication status
-    const currentSpaceIds: string[] = Array.isArray(memory.properties.space_ids)
-      ? memory.properties.space_ids
-      : [];
-    const currentGroupIds: string[] = Array.isArray(memory.properties.group_ids)
-      ? memory.properties.group_ids
-      : [];
-
-    // Validate that memory is actually published to the specified destinations
-    const notPublishedSpaces = spaces.filter(s => !currentSpaceIds.includes(s));
-    const notPublishedGroups = groups.filter(g => !currentGroupIds.includes(g));
-
-    if (notPublishedSpaces.length > 0 || notPublishedGroups.length > 0) {
-      logger.warn('Memory not published to some destinations', {
-        tool: 'remember_retract',
-        notPublishedSpaces,
-        notPublishedGroups,
-        currentSpaceIds,
-        currentGroupIds,
-      });
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Not published to destinations',
-          message: 'Memory is not published to some of the specified destinations',
-          context: {
-            not_published_spaces: notPublishedSpaces,
-            not_published_groups: notPublishedGroups,
-            current_spaces: currentSpaceIds,
-            current_groups: currentGroupIds,
-          },
-        },
-        null,
-        2
-      );
-    }
-
-    // Create confirmation request
-    const { requestId, token } = await confirmationTokenService.createRequest(
-      userId,
-      'retract_memory',
-      {
-        memory_id: args.memory_id,
-        spaces,
-        groups,
-        current_space_ids: currentSpaceIds,
-        current_group_ids: currentGroupIds,
-      }
-    );
-
-    logger.info('Retract confirmation request created', {
-      tool: 'remember_retract',
-      requestId,
-      userId,
-      memoryId: args.memory_id,
-      spaces,
-      groups,
-    });
-
-    // Build summary for user
-    const destinations: string[] = [];
-    if (spaces.length > 0) {
-      destinations.push(`spaces: ${spaces.join(', ')}`);
-    }
-    if (groups.length > 0) {
-      destinations.push(`groups: ${groups.join(', ')}`);
-    }
-
     return JSON.stringify(
       {
         success: true,
-        message: 'Retraction request created. Please confirm to proceed.',
+        token: result.token,
         action: 'retract_memory',
         memory_id: args.memory_id,
-        destinations: destinations.join('; '),
-        retraction_details: {
-          spaces: spaces.length > 0 ? {
-            action: 'orphan',
-            description: 'Memory will remain in Memory_spaces_public with updated tracking arrays (removed from space_ids)',
-            spaces,
-          } : null,
-          groups: groups.length > 0 ? {
-            action: 'orphan',
-            description: 'Memory will remain in Memory_groups_{groupId} with updated tracking arrays (removed from group_ids)',
-            groups,
-          } : null,
-        },
         confirmation_required: true,
       },
       null,