@prmichaelsen/remember-mcp 2.3.4 → 2.5.1

package/src/types/space-memory.ts

@@ -14,10 +14,12 @@ import type { Memory, SearchOptions, SearchResult } from './memory.js';
  */
 export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
   /**
-   * Space identifier (snake_case)
-   * Examples: 'the_void', 'public_space'
+   * Spaces this memory is published to (snake_case array)
+   * Examples: ['the_void'], ['dogs', 'cats'], ['the_void', 'dogs']
+   *
+   * A memory can belong to multiple spaces simultaneously.
    */
-  space_id: string;
+  spaces: string[];
 
   /**
    * Original author's user_id (for permissions)

package/src/weaviate/space-schema.spec.ts

@@ -8,6 +8,8 @@ import {
   getSpaceDisplayName,
   isValidSpaceId,
   ensureSpaceCollection,
+  ensurePublicCollection,
+  PUBLIC_COLLECTION_NAME,
 } from './space-schema';
 import type { WeaviateClient } from 'weaviate-client';
 
@@ -120,6 +122,7 @@ describe('Space Schema Utilities', () => {
       
       // Check for space-specific properties
       const propertyNames = createCall.properties.map((p: any) => p.name);
+      expect(propertyNames).toContain('spaces'); // ✅ New array field
       expect(propertyNames).toContain('space_id');
       expect(propertyNames).toContain('author_id');
       expect(propertyNames).toContain('ghost_id');
@@ -128,4 +131,56 @@ describe('Space Schema Utilities', () => {
       expect(propertyNames).toContain('attribution');
     });
   });
+
+  describe('Unified Public Collection', () => {
+    it('should create Memory_public collection', async () => {
+      const mockCollection = { name: 'Memory_public' };
+      (mockWeaviateClient.collections.exists as jest.Mock).mockResolvedValue(false);
+      (mockWeaviateClient.collections.create as jest.Mock).mockResolvedValue(undefined);
+      (mockWeaviateClient.collections.get as jest.Mock).mockReturnValue(mockCollection);
+
+      const result = await ensurePublicCollection(mockWeaviateClient);
+
+      expect(result).toBe(mockCollection);
+      expect(mockWeaviateClient.collections.exists).toHaveBeenCalledWith('Memory_public');
+      expect(mockWeaviateClient.collections.create).toHaveBeenCalled();
+      expect(mockWeaviateClient.collections.get).toHaveBeenCalledWith('Memory_public');
+    });
+
+    it('should return existing Memory_public if it exists', async () => {
+      const mockCollection = { name: 'Memory_public' };
+      (mockWeaviateClient.collections.exists as jest.Mock).mockResolvedValue(true);
+      (mockWeaviateClient.collections.get as jest.Mock).mockReturnValue(mockCollection);
+
+      const result = await ensurePublicCollection(mockWeaviateClient);
+
+      expect(result).toBe(mockCollection);
+      expect(mockWeaviateClient.collections.exists).toHaveBeenCalledWith('Memory_public');
+      expect(mockWeaviateClient.collections.get).toHaveBeenCalledWith('Memory_public');
+      expect(mockWeaviateClient.collections.create).not.toHaveBeenCalled();
+    });
+
+    it('should have spaces array field in schema', async () => {
+      (mockWeaviateClient.collections.exists as jest.Mock).mockResolvedValue(false);
+      (mockWeaviateClient.collections.create as jest.Mock).mockResolvedValue(undefined);
+      (mockWeaviateClient.collections.get as jest.Mock).mockReturnValue({});
+
+      await ensurePublicCollection(mockWeaviateClient);
+
+      const createCall = (mockWeaviateClient.collections.create as jest.Mock).mock.calls[0][0];
+      const propertyNames = createCall.properties.map((p: any) => p.name);
+      
+      // Verify spaces array field exists
+      expect(propertyNames).toContain('spaces');
+      
+      // Find spaces property and verify it's an array
+      const spacesProperty = createCall.properties.find((p: any) => p.name === 'spaces');
+      expect(spacesProperty).toBeDefined();
+      expect(spacesProperty.dataType).toBe('text[]');
+    });
+
+    it('should verify PUBLIC_COLLECTION_NAME constant', () => {
+      expect(PUBLIC_COLLECTION_NAME).toBe('Memory_public');
+    });
+  });
 });

package/src/weaviate/space-schema.ts

@@ -9,12 +9,18 @@ import weaviate, { type WeaviateClient, type Collection } from 'weaviate-client'
 import { config } from '../config.js';
 import { SUPPORTED_SPACES, type SpaceId } from '../types/space-memory.js';
 
+/**
+ * Unified public collection name for all public spaces
+ */
+export const PUBLIC_COLLECTION_NAME = 'Memory_public';
+
 /**
  * Get collection name for a space
- * 
+ *
+ * @deprecated Use PUBLIC_COLLECTION_NAME instead. Will be removed in v3.0.0.
  * @param spaceId - Space identifier (snake_case)
  * @returns Collection name in format Memory_{space_id}
- * 
+ *
  * @example
  * getSpaceCollectionName('the_void') // Returns 'Memory_the_void'
  */
@@ -72,7 +78,10 @@ async function createSpaceCollection(
   client: WeaviateClient,
   spaceId: string
 ): Promise<void> {
-  const collectionName = getSpaceCollectionName(spaceId);
+  // Handle 'public' as special case for unified collection
+  const collectionName = spaceId === 'public'
+    ? PUBLIC_COLLECTION_NAME
+    : getSpaceCollectionName(spaceId);
 
   console.log(`[Weaviate] Creating space collection ${collectionName}...`);
 
@@ -96,10 +105,15 @@ async function createSpaceCollection(
       },
 
       // Space identity
+      {
+        name: 'spaces',
+        dataType: 'text[]' as any,
+        description: 'Spaces this memory is published to (e.g., ["the_void", "dogs"])',
+      },
       {
         name: 'space_id',
         dataType: 'text' as any,
-        description: 'Space identifier (e.g., "the_void")',
+        description: 'DEPRECATED: Use spaces array instead. Will be removed in v3.0.0.',
       },
       {
         name: 'author_id',
@@ -243,13 +257,38 @@ async function createSpaceCollection(
   console.log(`[Weaviate] Space collection ${collectionName} created successfully`);
 }
 
+/**
+ * Ensure the unified public collection exists, creating it if needed
+ *
+ * @param client - Weaviate client
+ * @returns Collection reference to Memory_public
+ *
+ * @example
+ * const collection = await ensurePublicCollection(client);
+ */
+export async function ensurePublicCollection(
+  client: WeaviateClient
+): Promise<Collection<any>> {
+  const collectionName = PUBLIC_COLLECTION_NAME;
+
+  // Check if collection exists
+  const exists = await client.collections.exists(collectionName);
+  
+  if (!exists) {
+    await createSpaceCollection(client, 'public');
+  }
+
+  return client.collections.get(collectionName);
+}
+
 /**
  * Ensure a space collection exists, creating it if needed
- * 
+ *
+ * @deprecated Use ensurePublicCollection() instead. Will be removed in v3.0.0.
  * @param client - Weaviate client
  * @param spaceId - Space identifier
  * @returns Collection reference
- * 
+ *
  * @example
  * const collection = await ensureSpaceCollection(client, 'the_void');
  */