@prmichaelsen/remember-mcp 2.3.4 → 2.5.1

package/src/services/confirmation-token.service.ts

@@ -50,40 +50,84 @@ export class ConfirmationTokenService {
     payload: any,
     targetCollection?: string
   ): Promise<{ requestId: string; token: string }> {
-    const token = randomUUID();
+    try {
+      const token = randomUUID();
 
-    const now = new Date();
-    const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1000);
+      const now = new Date();
+      const expiresAt = new Date(now.getTime() + this.EXPIRY_MINUTES * 60 * 1000);
 
-    const request: ConfirmationRequest = {
-      user_id: userId,
-      token,
-      action,
-      target_collection: targetCollection,
-      payload,
-      created_at: now.toISOString(),
-      expires_at: expiresAt.toISOString(),
-      status: 'pending',
-    };
+      const request: ConfirmationRequest = {
+        user_id: userId,
+        token,
+        action,
+        target_collection: targetCollection,
+        payload,
+        created_at: now.toISOString(),
+        expires_at: expiresAt.toISOString(),
+        status: 'pending',
+      };
 
-    // Add document to Firestore (auto-generates ID)
-    const collectionPath = `users/${userId}/requests`;
-    console.log('[ConfirmationTokenService] Creating request:', {
-      userId,
-      action,
-      targetCollection,
-      collectionPath,
-    });
-    
-    const docRef = await addDocument(collectionPath, request);
-    
-    console.log('[ConfirmationTokenService] Request created:', {
-      requestId: docRef.id,
-      token,
-      expiresAt: request.expires_at,
-    });
+      // Add document to Firestore (auto-generates ID)
+      const collectionPath = `users/${userId}/requests`;
+      console.log('[ConfirmationTokenService] Creating request:', {
+        userId,
+        action,
+        targetCollection,
+        collectionPath,
+        requestData: {
+          token,
+          action,
+          payloadKeys: Object.keys(payload),
+        },
+      });
+      
+      console.log('[ConfirmationTokenService] Calling addDocument...');
+      const docRef = await addDocument(collectionPath, request);
+      console.log('[ConfirmationTokenService] addDocument returned:', {
+        hasDocRef: !!docRef,
+        hasId: !!docRef?.id,
+        docRefId: docRef?.id,
+      });
+      
+      // Validate docRef
+      if (!docRef) {
+        const error = new Error('Firestore addDocument returned null/undefined');
+        console.error('[ConfirmationTokenService] CRITICAL: addDocument returned null', {
+          userId,
+          collectionPath,
+        });
+        throw error;
+      }
+      
+      if (!docRef.id) {
+        const error = new Error('Firestore addDocument returned docRef without ID');
+        console.error('[ConfirmationTokenService] CRITICAL: docRef has no ID', {
+          userId,
+          collectionPath,
+          docRef,
+        });
+        throw error;
+      }
+      
+      console.log('[ConfirmationTokenService] Request created successfully:', {
+        requestId: docRef.id,
+        token,
+        expiresAt: request.expires_at,
+      });
 
-    return { requestId: docRef.id, token };
+      return { requestId: docRef.id, token };
+    } catch (error) {
+      console.error('[ConfirmationTokenService] FAILED to create request:', {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+        userId,
+        action,
+        collectionPath: `users/${userId}/requests`,
+      });
+      
+      // Re-throw so caller (tool handler) can catch and return error response
+      throw error;
+    }
   }
 
   /**

package/src/tools/confirm.ts

@@ -8,7 +8,7 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { confirmationTokenService, type ConfirmationRequest } from '../services/confirmation-token.service.js';
 import { getWeaviateClient, getMemoryCollectionName } from '../weaviate/client.js';
-import { ensureSpaceCollection } from '../weaviate/space-schema.js';
+import { ensurePublicCollection } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 
 /**
@@ -102,7 +102,8 @@ async function executePublishMemory(
     console.log('[executePublishMemory] Starting execution:', {
       userId,
       memoryId: request.payload.memory_id,
-      targetSpace: request.target_collection,
+      spaces: request.payload.spaces,
+      spaceCount: request.payload.spaces?.length || 0,
     });
     
     // Fetch the memory NOW (during confirmation, not from stored payload)
@@ -149,15 +150,12 @@ async function executePublishMemory(
       );
     }
     
-    console.log('[executePublishMemory] Ensuring space collection:', request.target_collection || 'the_void');
+    console.log('[executePublishMemory] Ensuring public collection');
 
-    // Get target collection
-    const targetCollection = await ensureSpaceCollection(
-      weaviateClient,
-      request.target_collection || 'the_void'
-    );
+    // Get unified public collection
+    const publicCollection = await ensurePublicCollection(weaviateClient);
     
-    console.log('[executePublishMemory] Space collection ready');
+    console.log('[executePublishMemory] Public collection ready');
 
     // Create published memory (copy with modifications)
     const originalTags = Array.isArray(originalMemory.properties.tags)
@@ -171,7 +169,7 @@ async function executePublishMemory(
     const publishedMemory = {
       ...originalMemory.properties,
       // Add space-specific fields
-      space_id: request.target_collection || 'the_void',
+      spaces: request.payload.spaces || ['the_void'],  // ✅ Array of spaces!
       author_id: userId, // Track original author
       published_at: new Date().toISOString(),
       discovery_count: 0,
@@ -185,27 +183,28 @@ async function executePublishMemory(
       version: 1,
     };
 
-    console.log('[executePublishMemory] Inserting into space collection:', {
-      spaceId: request.target_collection || 'the_void',
+    console.log('[executePublishMemory] Inserting into Memory_public:', {
+      spaces: request.payload.spaces,
+      spaceCount: request.payload.spaces?.length || 0,
       memoryId: request.payload.memory_id,
       hasUserId: !!(publishedMemory as any).user_id,
       hasAuthorId: !!publishedMemory.author_id,
-      hasSpaceId: !!publishedMemory.space_id,
     });
     
-    // Insert directly - publishedMemory is already the properties object
-    const result = await targetCollection.data.insert(publishedMemory as any);
+    // Insert directly into unified public collection
+    const result = await publicCollection.data.insert(publishedMemory as any);
     
     console.log('[executePublishMemory] Insert result:', {
       success: !!result,
       spaceMemoryId: result,
     });
 
-    // Return minimal response - agent already knows original memory
+    // Return minimal response with spaces array
     return JSON.stringify(
       {
         success: true,
         space_memory_id: result,
+        spaces: request.payload.spaces || ['the_void'],
       },
       null,
       2

package/src/tools/publish.ts

@@ -17,7 +17,7 @@ import { SUPPORTED_SPACES } from '../types/space-memory.js';
  */
 export const publishTool: Tool = {
   name: 'remember_publish',
-  description: 'Publish a memory to a shared space (like "The Void"). The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token. Use remember_confirm to execute.',
+  description: 'Publish a memory to one or more shared spaces (like "The Void"). The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token. Use remember_confirm to execute.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -25,11 +25,15 @@ export const publishTool: Tool = {
         type: 'string',
         description: 'ID of the memory from your personal collection to publish',
       },
-      target: {
-        type: 'string',
-        description: 'Target space to publish to (snake_case ID)',
-        enum: SUPPORTED_SPACES,
-        default: 'the_void',
+      spaces: {
+        type: 'array',
+        items: {
+          type: 'string',
+          enum: SUPPORTED_SPACES,
+        },
+        description: 'Spaces to publish to (e.g., ["the_void", "dogs"]). Can publish to multiple spaces at once.',
+        minItems: 1,
+        default: ['the_void'],
       },
       additional_tags: {
         type: 'array',
@@ -38,13 +42,13 @@ export const publishTool: Tool = {
         default: [],
       },
     },
-    required: ['memory_id', 'target'],
+    required: ['memory_id', 'spaces'],
   },
 };
 
 interface PublishArgs {
   memory_id: string;
-  target: string;
+  spaces: string[];
   additional_tags?: string[];
 }
 
@@ -59,20 +63,23 @@ export async function handlePublish(
     console.log('[remember_publish] Starting publish request:', {
       userId,
       memoryId: args.memory_id,
-      target: args.target,
+      spaces: args.spaces,
+      spaceCount: args.spaces.length,
       additionalTags: args.additional_tags?.length || 0,
     });
     
-    // Validate space ID
-    if (!isValidSpaceId(args.target)) {
-      console.log('[remember_publish] Invalid space ID:', args.target);
+    // Validate all space IDs
+    const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
+    if (invalidSpaces.length > 0) {
+      console.log('[remember_publish] Invalid space IDs:', invalidSpaces);
       return JSON.stringify(
         {
           success: false,
-          error: 'Invalid space ID',
-          message: `Space "${args.target}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
+          error: 'Invalid space IDs',
+          message: `Invalid spaces: ${invalidSpaces.join(', ')}. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
           context: {
-            provided_space: args.target,
+            invalid_spaces: invalidSpaces,
+            provided_spaces: args.spaces,
             supported_spaces: SUPPORTED_SPACES,
           },
         },
@@ -80,6 +87,20 @@ export async function handlePublish(
         2
       );
     }
+    
+    // Validate not empty
+    if (args.spaces.length === 0) {
+      console.log('[remember_publish] Empty spaces array');
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Empty spaces array',
+          message: 'Must specify at least one space to publish to',
+        },
+        null,
+        2
+      );
+    }
 
     // Verify memory exists and user owns it
     const weaviateClient = getWeaviateClient();
@@ -147,20 +168,21 @@ export async function handlePublish(
       );
     }
 
-    // Create payload with only memory_id (content fetched during confirmation)
+    // Create payload with memory_id and spaces array
     const payload = {
       memory_id: args.memory_id,
+      spaces: args.spaces,
       additional_tags: args.additional_tags || [],
     };
 
     console.log('[remember_publish] Generating confirmation token');
     
     // Generate confirmation token
-    const { requestId, token } = await confirmationTokenService.createRequest(
+    const { requestId, token} = await confirmationTokenService.createRequest(
       userId,
       'publish_memory',
       payload,
-      args.target
+      undefined  // No single target_collection anymore
     );
     
     console.log('[remember_publish] Token generated:', {
@@ -179,12 +201,12 @@ export async function handlePublish(
       2
     );
   } catch (error) {
-    handleToolError(error, {
+    return handleToolError(error, {
       toolName: 'remember_publish',
       userId,
       operation: 'publish memory',
       memory_id: args.memory_id,
-      target: args.target,
+      spaces: args.spaces,
     });
   }
 }

package/src/tools/query-space.ts

@@ -8,7 +8,7 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { Filters } from 'weaviate-client';
 import { getWeaviateClient } from '../weaviate/client.js';
-import { ensureSpaceCollection, isValidSpaceId } from '../weaviate/space-schema.js';
+import { ensurePublicCollection, isValidSpaceId } from '../weaviate/space-schema.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
 import { handleToolError } from '../utils/error-handler.js';
 
@@ -66,13 +66,13 @@ export const querySpaceTool: Tool = {
         description: 'Output format: detailed (full objects) or compact (text summary)',
       },
     },
-    required: ['question', 'space'],
+    required: ['question', 'spaces'],
   },
 };
 
 interface QuerySpaceArgs {
   question: string;
-  space: string;
+  spaces: string[];
   content_type?: string;
   tags?: string[];
   min_weight?: number;
@@ -90,13 +90,27 @@ export async function handleQuerySpace(
   userId: string  // May be used for private spaces in future
 ): Promise<string> {
   try {
-    // Validate space ID
-    if (!isValidSpaceId(args.space)) {
+    // Validate all space IDs
+    const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
+    if (invalidSpaces.length > 0) {
       return JSON.stringify(
         {
           success: false,
-          error: 'Invalid space ID',
-          message: `Space "${args.space}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
+          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
@@ -104,47 +118,47 @@ export async function handleQuerySpace(
     }
 
     const weaviateClient = getWeaviateClient();
-    const spaceCollection = await ensureSpaceCollection(weaviateClient, args.space);
+    const publicCollection = await ensurePublicCollection(weaviateClient);
 
     // Build filters
     const filterList: any[] = [];
 
-    // Filter by space_id
-    filterList.push(spaceCollection.filter.byProperty('space_id').equal(args.space));
+    // 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 (space_memory)
-    filterList.push(spaceCollection.filter.byProperty('doc_type').equal('space_memory'));
+    filterList.push(publicCollection.filter.byProperty('doc_type').equal('space_memory'));
 
     // Apply content type filter
     if (args.content_type) {
-      filterList.push(spaceCollection.filter.byProperty('type').equal(args.content_type));
+      filterList.push(publicCollection.filter.byProperty('type').equal(args.content_type));
     }
 
     // Apply tags filter
     if (args.tags && args.tags.length > 0) {
       args.tags.forEach(tag => {
-        filterList.push(spaceCollection.filter.byProperty('tags').containsAny([tag]));
+        filterList.push(publicCollection.filter.byProperty('tags').containsAny([tag]));
       });
     }
 
     // Apply weight filter
     if (args.min_weight !== undefined) {
-      filterList.push(spaceCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
+      filterList.push(publicCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
     }
 
     // Apply date filters
     if (args.date_from) {
-      filterList.push(spaceCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
+      filterList.push(publicCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
     }
 
     if (args.date_to) {
-      filterList.push(spaceCollection.filter.byProperty('created_at').lessOrEqual(new Date(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;
 
     // Execute semantic search using nearText
-    const searchResults = await spaceCollection.query.nearText(args.question, {
+    const searchResults = await publicCollection.query.nearText(args.question, {
       limit: args.limit || 10,
       ...(whereFilter && { where: whereFilter }),
     });
@@ -154,14 +168,14 @@ export async function handleQuerySpace(
 
     if (format === 'compact') {
       // Compact format: text summary for LLM context
-      const summaries = searchResults.objects.map((obj, idx) => {
+      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 result = {
         question: args.question,
-        space: args.space,
+        spaces_queried: args.spaces,
         format: 'compact',
         summary: summaries.join('\n'),
         count: searchResults.objects.length,
@@ -170,7 +184,7 @@ export async function handleQuerySpace(
       return JSON.stringify(result, null, 2);
     } else {
       // Detailed format: full objects
-      const memories = searchResults.objects.map((obj) => ({
+      const memories = searchResults.objects.map((obj: any) => ({
         id: obj.uuid,
         ...obj.properties,
         _distance: obj.metadata?.distance,
@@ -178,7 +192,7 @@ export async function handleQuerySpace(
 
       const result = {
         question: args.question,
-        space: args.space,
+        spaces_queried: args.spaces,
         format: 'detailed',
         memories,
         total: memories.length,
@@ -187,10 +201,10 @@ export async function handleQuerySpace(
       return JSON.stringify(result, null, 2);
     }
   } catch (error) {
-    handleToolError(error, {
+    return handleToolError(error, {
       toolName: 'remember_query_space',
-      operation: 'query space',
-      space: args.space,
+      operation: 'query spaces',
+      spaces: args.spaces,
       question: args.question,
     });
   }

package/src/tools/search-space.ts

@@ -8,7 +8,7 @@
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { Filters } from 'weaviate-client';
 import { getWeaviateClient } from '../weaviate/client.js';
-import { ensureSpaceCollection, isValidSpaceId } from '../weaviate/space-schema.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 type { SearchFilters } from '../types/memory.js';
@@ -18,7 +18,7 @@ import type { SearchFilters } from '../types/memory.js';
  */
 export const searchSpaceTool: Tool = {
   name: 'remember_search_space',
-  description: 'Search shared spaces to discover thoughts, ideas, and memories. Works like remember_search_memory but searches shared spaces instead of personal memories.',
+  description: 'Search one or more shared spaces to discover thoughts, ideas, and memories. Works like remember_search_memory but searches shared spaces instead of personal memories. Can search multiple spaces in a single query.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -26,11 +26,15 @@ export const searchSpaceTool: Tool = {
         type: 'string',
         description: 'Search query (semantic + keyword hybrid)',
       },
-      space: {
-        type: 'string',
-        description: 'Which space to search',
-        enum: SUPPORTED_SPACES,
-        default: 'the_void',
+      spaces: {
+        type: 'array',
+        items: {
+          type: 'string',
+          enum: SUPPORTED_SPACES,
+        },
+        description: 'Spaces to search (e.g., ["the_void", "dogs"]). Can search multiple spaces at once.',
+        minItems: 1,
+        default: ['the_void'],
       },
       content_type: {
         type: 'string',
@@ -72,13 +76,13 @@ export const searchSpaceTool: Tool = {
         description: 'Offset for pagination',
       },
     },
-    required: ['query', 'space'],
+    required: ['query', 'spaces'],
   },
 };
 
 interface SearchSpaceArgs {
   query: string;
-  space: string;
+  spaces: string[];
   content_type?: string;
   tags?: string[];
   min_weight?: number;
@@ -97,13 +101,32 @@ export async function handleSearchSpace(
   userId: string  // May be used for private spaces in future
 ): Promise<string> {
   try {
-    // Validate space ID
-    if (!isValidSpaceId(args.space)) {
+    // Validate all space IDs
+    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(', ')}`,
+          context: {
+            invalid_spaces: invalidSpaces,
+            provided_spaces: args.spaces,
+            supported_spaces: SUPPORTED_SPACES,
+          },
+        },
+        null,
+        2
+      );
+    }
+    
+    // Validate not empty
+    if (args.spaces.length === 0) {
       return JSON.stringify(
         {
           success: false,
-          error: 'Invalid space ID',
-          message: `Space "${args.space}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
+          error: 'Empty spaces array',
+          message: 'Must specify at least one space to search',
         },
         null,
         2
@@ -111,51 +134,51 @@ export async function handleSearchSpace(
     }
 
     const weaviateClient = getWeaviateClient();
-    const spaceCollection = await ensureSpaceCollection(weaviateClient, args.space);
+    const publicCollection = await ensurePublicCollection(weaviateClient);
 
     // Build filters for space search
     const filterList: any[] = [];
 
-    // Filter by space_id
-    filterList.push(spaceCollection.filter.byProperty('space_id').equal(args.space));
+    // 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 (space_memory)
-    filterList.push(spaceCollection.filter.byProperty('doc_type').equal('space_memory'));
+    filterList.push(publicCollection.filter.byProperty('doc_type').equal('space_memory'));
 
     // Apply content type filter
     if (args.content_type) {
-      filterList.push(spaceCollection.filter.byProperty('type').equal(args.content_type));
+      filterList.push(publicCollection.filter.byProperty('type').equal(args.content_type));
     }
 
     // Apply tags filter
     if (args.tags && args.tags.length > 0) {
       args.tags.forEach(tag => {
-        filterList.push(spaceCollection.filter.byProperty('tags').containsAny([tag]));
+        filterList.push(publicCollection.filter.byProperty('tags').containsAny([tag]));
       });
     }
 
     // Apply weight filters
     if (args.min_weight !== undefined) {
-      filterList.push(spaceCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
+      filterList.push(publicCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
     }
 
     if (args.max_weight !== undefined) {
-      filterList.push(spaceCollection.filter.byProperty('weight').lessOrEqual(args.max_weight));
+      filterList.push(publicCollection.filter.byProperty('weight').lessOrEqual(args.max_weight));
     }
 
     // Apply date filters (convert ISO strings to Date objects)
     if (args.date_from) {
-      filterList.push(spaceCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
+      filterList.push(publicCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
     }
 
     if (args.date_to) {
-      filterList.push(spaceCollection.filter.byProperty('created_at').lessOrEqual(new Date(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;
 
     // Execute hybrid search
-    const searchResults = await spaceCollection.query.hybrid(args.query, {
+    const searchResults = await publicCollection.query.hybrid(args.query, {
       limit: args.limit || 10,
       offset: args.offset || 0,
       ...(whereFilter && { where: whereFilter }),
@@ -169,7 +192,7 @@ export async function handleSearchSpace(
     }));
 
     const result = {
-      space: args.space,
+      spaces_searched: args.spaces,
       query: args.query,
       memories,
       total: memories.length,
@@ -179,10 +202,10 @@ export async function handleSearchSpace(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    handleToolError(error, {
+    return handleToolError(error, {
       toolName: 'remember_search_space',
-      operation: 'search space',
-      space: args.space,
+      operation: 'search spaces',
+      spaces: args.spaces,
       query: args.query,
     });
   }