@prmichaelsen/remember-mcp 2.3.4 → 2.5.0

package/CHANGELOG.md

@@ -5,6 +5,48 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.0] - 2026-02-16
+
+### ✨ Added
+
+- **Multi-Space Support**: Publish and search across multiple spaces simultaneously
+  - `spaces` array parameter in `remember_publish` (replaces `target`)
+  - `spaces` array parameter in `remember_search_space` (replaces `space`)
+  - `spaces` array parameter in `remember_query_space` (replaces `space`)
+  - Single memory can belong to multiple spaces
+  - No duplication - one memory, multiple spaces
+  - Search multiple spaces in one query
+
+- **Unified Public Collection**: `Memory_public` replaces per-space collections
+  - All public memories in single collection
+  - Efficient storage (N× reduction in documents)
+  - Simpler architecture
+  - Uses `containsAny` filter for multi-space queries
+
+### 🔧 Changed
+
+- **SpaceMemory type**: `space_id: string` → `spaces: string[]`
+- **remember_publish**: `target` parameter → `spaces` array
+- **remember_search_space**: `space` parameter → `spaces` array
+- **remember_query_space**: `space` parameter → `spaces` array
+- **Collection strategy**: Per-space collections → Unified `Memory_public`
+- **Search results**: Include `spaces_searched` or `spaces_queried` in response
+
+### 📚 Documentation
+
+- Created Milestone 11: Unified Public Collection
+- Created Tasks 46-54 for implementation
+- Created design document: `agent/design/unified-public-collection.md`
+- Created design document: `agent/design/comment-memory-type.md`
+
+### ⚠️ Deprecation
+
+- `ensureSpaceCollection()` deprecated (use `ensurePublicCollection()`)
+- `getSpaceCollectionName()` deprecated (use `PUBLIC_COLLECTION_NAME`)
+- Per-space collections (`Memory_the_void`, etc.) will be removed in v3.0.0
+
+---
+
 ## [2.3.3] - 2026-02-16
 
 ### 🐛 Fixed

package/README.md

@@ -149,12 +149,41 @@ await wrapped.start();
 ## Architecture
 
 - **Weaviate**: Vector storage for memories, relationships, and shared spaces
-  - Personal collections: `Memory_{user_id}`
-  - Shared collections: `Memory_the_void`, `Memory_public_space`
+  - Personal collections: `Memory_{user_id}` (per-user isolation)
+  - Unified public collection: `Memory_public` (all public spaces)
+  - Multi-space support: Memories can belong to multiple spaces via `spaces` array
 - **Firestore**: Permissions, preferences, confirmation tokens
   - User data: `users/{user_id}/preferences`, `users/{user_id}/requests`
 - **Firebase Auth**: User authentication
 
+### Multi-Space Architecture (v2.4.0+)
+
+**Unified Collection**: All public memories stored in single `Memory_public` collection
+
+**Benefits**:
+- ✅ Search multiple spaces in one query
+- ✅ Publish to multiple spaces in one operation
+- ✅ No memory duplication
+- ✅ Efficient storage (N× reduction)
+
+**Example**:
+```typescript
+// One memory, three spaces
+{
+  "id": "abc123",
+  "spaces": ["the_void", "dogs", "cats"],
+  "content": "My dog is adorable!",
+  "author_id": "user123"
+}
+
+// Search across spaces
+remember_search_space({
+  spaces: ["the_void", "dogs"],
+  query: "adorable pets"
+})
+// Finds memories published to ANY of the requested spaces
+```
+
 ## Shared Spaces
 
 Publish memories to shared discovery spaces where other users can find them.
@@ -167,19 +196,35 @@ Publish memories to shared discovery spaces where other users can find them.
 
 1. **Request Publication**: Generate confirmation token
 ```typescript
-remember_publish({ memory_id: "abc123", target: "the_void" })
+// Publish to single space
+remember_publish({ memory_id: "abc123", spaces: ["the_void"] })
+
+// Publish to multiple spaces at once!
+remember_publish({ memory_id: "abc123", spaces: ["the_void", "dogs", "cats"] })
+
 // Returns: { success: true, token: "xyz789" }
 ```
 
 2. **User Confirms**: Execute the publication
 ```typescript
 remember_confirm({ token: "xyz789" })
-// Returns: { success: true, space_memory_id: "new-id" }
+// Returns: {
+//   success: true,
+//   space_memory_id: "new-id",
+//   spaces: ["the_void", "dogs", "cats"]
+// }
 ```
 
 3. **Discover**: Search shared spaces
 ```typescript
-remember_search_space({ query: "interesting ideas", space: "the_void" })
+// Search single space
+remember_search_space({ query: "interesting ideas", spaces: ["the_void"] })
+
+// Search multiple spaces at once!
+remember_search_space({
+  query: "cute dog pictures",
+  spaces: ["the_void", "dogs"]
+})
 ```
 
 ### Space Tools (5 new)

package/agent/milestones/milestone-11-unified-public-collection.md

@@ -0,0 +1,205 @@
+# Milestone 11: Unified Public Collection
+
+**Goal**: Implement unified `Memory_public` collection with multi-space support
+**Duration**: 1-2 weeks
+**Dependencies**: M10 (Shared Spaces & Confirmation Flow)
+**Status**: Not Started
+
+---
+
+## Overview
+
+Replace per-space collections (`Memory_the_void`, `Memory_dogs`, etc.) with a unified `Memory_public` collection where memories can belong to multiple spaces simultaneously. This enables multi-space search, eliminates duplication, and provides a more flexible and scalable architecture.
+
+This milestone introduces:
+- **Unified Collection**: Single `Memory_public` for all public spaces
+- **Multi-Space Support**: `spaces: string[]` array instead of single `space_id`
+- **Multi-Space Search**: Query multiple spaces in one call
+- **No Duplication**: One memory, multiple spaces
+- **Efficient Storage**: N× reduction in documents
+
+---
+
+## Deliverables
+
+### 1. Type System Updates
+- Update `SpaceMemory` interface: `space_id: string` → `spaces: string[]`
+- Update type exports and constants
+- Backward compatibility considerations
+
+### 2. Schema Updates
+- Add `spaces` array field to Weaviate schema
+- Create `Memory_public` collection
+- Update space schema utilities
+- Collection name constants
+
+### 3. Tool Updates (5 tools)
+- Update `remember_publish` - Support `spaces` array parameter
+- Update `remember_confirm` - Handle multi-space publishing
+- Update `remember_search_space` - Multi-space search with `containsAny`
+- Update `remember_query_space` - Multi-space RAG queries
+- Update `remember_deny` - No changes needed
+
+### 4. Migration Strategy
+- Backward compatibility during transition
+- Data migration plan (if needed)
+- Deprecation timeline
+
+### 5. Testing & Documentation
+- Update unit tests for all affected tools
+- Add multi-space test scenarios
+- Update README with multi-space examples
+- Update API documentation
+
+---
+
+## Success Criteria
+
+- [ ] `SpaceMemory` type uses `spaces: string[]`
+- [ ] `Memory_public` collection created successfully
+- [ ] `remember_publish` accepts `spaces` array
+- [ ] Can publish to multiple spaces in one call
+- [ ] `remember_search_space` accepts `spaces` array
+- [ ] Multi-space search returns results from all requested spaces
+- [ ] No memory duplication across spaces
+- [ ] All 5 space tools work with new architecture
+- [ ] TypeScript compiles without errors
+- [ ] All tests passing (including new multi-space tests)
+- [ ] Build successful
+- [ ] README updated with multi-space examples
+- [ ] Backward compatibility maintained (if applicable)
+
+---
+
+## Key Files to Modify
+
+```
+src/
+├── types/
+│   └── space-memory.ts              # Update SpaceMemory interface
+├── weaviate/
+│   └── space-schema.ts              # Update schema, add Memory_public
+└── tools/
+    ├── publish.ts                   # Support spaces array
+    ├── confirm.ts                   # Handle multi-space publish
+    ├── search-space.ts              # Multi-space search
+    └── query-space.ts               # Multi-space query
+
+tests/
+└── unit/
+    ├── space-schema.test.ts         # Add multi-space tests
+    ├── publish.test.ts              # Add multi-space tests
+    ├── search-space.test.ts         # Add multi-space tests
+    └── query-space.test.ts          # Add multi-space tests
+```
+
+---
+
+## Implementation Tasks
+
+See individual task documents:
+- Task 46: Update SpaceMemory Types for Multi-Space
+- Task 47: Update Space Schema with Spaces Array
+- Task 48: Create Memory_public Collection
+- Task 49: Update remember_publish for Multi-Space
+- Task 50: Update remember_confirm for Multi-Space
+- Task 51: Update remember_search_space for Multi-Space
+- Task 52: Update remember_query_space for Multi-Space
+- Task 53: Add Multi-Space Unit Tests
+- Task 54: Update Documentation for Multi-Space
+
+---
+
+## Architecture Notes
+
+### Before (Per-Space Collections)
+```
+Memory_the_void     → Only "The Void" memories
+Memory_dogs         → Only "Dogs" memories
+Memory_cats         → Only "Cats" memories
+```
+
+**Problems**:
+- Can't search multiple spaces at once
+- Memory duplication if published to multiple spaces
+- Collection proliferation
+
+### After (Unified Collection)
+```
+Memory_public       → ALL public memories
+  - spaces: ["the_void"]
+  - spaces: ["dogs", "cats"]
+  - spaces: ["the_void", "dogs"]
+```
+
+**Benefits**:
+- ✅ Multi-space search in one query
+- ✅ No duplication
+- ✅ Efficient storage
+- ✅ Flexible space management
+
+### Multi-Space Search Example
+```typescript
+remember_search_space({
+  spaces: ["the_void", "dogs"],  // ✅ Multiple spaces!
+  query: "cute dog pictures"
+})
+
+// Weaviate filter:
+collection.filter.byProperty('spaces').containsAny(['the_void', 'dogs'])
+```
+
+---
+
+## Migration Strategy
+
+### Phase 1: Add Support (v2.4.0 - Backward Compatible)
+- Add `spaces` field to schema (keep `space_id` temporarily)
+- Support both `space` and `spaces` parameters
+- Create `Memory_public` collection
+- Dual-write to both old and new collections
+
+### Phase 2: Migrate Data (v2.5.0)
+- Copy existing memories from per-space to unified
+- Verify data integrity
+- Mark old collections as deprecated
+
+### Phase 3: Remove Old (v3.0.0 - Breaking Change)
+- Remove `space_id` field
+- Remove per-space collections
+- Remove backward compatibility code
+- Update all documentation
+
+---
+
+## Testing Strategy
+
+1. **Unit Tests**: Each tool with multi-space scenarios
+2. **Integration Tests**: Full publish → search workflow
+3. **Migration Tests**: Data migration validation
+4. **Performance Tests**: Compare single vs. multi-space queries
+
+---
+
+## Breaking Changes
+
+**v3.0.0 (Future)**:
+- Remove `space_id` field from SpaceMemory
+- Remove per-space collections
+- Remove `space` parameter (use `spaces` only)
+
+**Migration Guide**:
+```typescript
+// Before (v2.3.x)
+remember_publish({ memory_id: "abc", target: "the_void" })
+remember_search_space({ space: "the_void", query: "..." })
+
+// After (v3.0.0)
+remember_publish({ memory_id: "abc", spaces: ["the_void"] })
+remember_search_space({ spaces: ["the_void"], query: "..." })
+```
+
+---
+
+**Next Milestone**: M12 - Comment System (3 schema fields only!)
+**Blockers**: None (builds on M10)

package/agent/tasks/task-46-update-spacememory-types.md

@@ -0,0 +1,94 @@
+# Task 46: Update SpaceMemory Types for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 1 hour
+**Dependencies**: None
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `SpaceMemory` interface to use `spaces: string[]` instead of `space_id: string`, enabling memories to belong to multiple spaces simultaneously.
+
+---
+
+## Steps
+
+### 1. Update SpaceMemory Interface
+
+**File**: `src/types/space-memory.ts`
+
+**Changes**:
+```typescript
+// Before
+export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
+  space_id: string;  // ❌ Single space
+  author_id: string;
+  // ...
+}
+
+// After
+export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
+  spaces: string[];  // ✅ Multiple spaces!
+  author_id: string;
+  // ...
+}
+```
+
+### 2. Update Type Exports
+
+**File**: `src/types/space-memory.ts`
+
+- Update `SpaceSearchOptions` if needed
+- Update `SpaceSearchResult` if needed
+- Keep `SpaceId` type and `SUPPORTED_SPACES` constant
+
+### 3. Add Backward Compatibility (Optional)
+
+Consider adding a migration helper:
+```typescript
+export function migrateSpaceMemory(old: any): SpaceMemory {
+  if (old.space_id && !old.spaces) {
+    return {
+      ...old,
+      spaces: [old.space_id],
+    };
+  }
+  return old;
+}
+```
+
+### 4. Update Type Tests
+
+**File**: Create `src/types/space-memory.spec.ts` if needed
+
+Test that:
+- SpaceMemory interface has `spaces` array
+- Type checking works correctly
+- Migration helper works (if implemented)
+
+---
+
+## Verification
+
+- [ ] `SpaceMemory` interface uses `spaces: string[]`
+- [ ] No `space_id` field in interface
+- [ ] Type exports updated
+- [ ] TypeScript compiles without errors
+- [ ] No breaking changes to existing code (yet)
+- [ ] Documentation comments updated
+
+---
+
+## Files Modified
+
+- `src/types/space-memory.ts` - Update interface
+
+## Files Created
+
+- `src/types/space-memory.spec.ts` - Type tests (optional)
+
+---
+
+**Next Task**: Task 47 - Update Space Schema with Spaces Array

package/agent/tasks/task-47-update-space-schema.md

@@ -0,0 +1,102 @@
+# Task 47: Update Space Schema with Spaces Array
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 46
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the Weaviate space collection schema to include a `spaces` array field and prepare for the unified `Memory_public` collection.
+
+---
+
+## Steps
+
+### 1. Add Spaces Field to Schema
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Add property**:
+```typescript
+{
+  name: 'spaces',
+  dataType: 'text[]' as any,
+  description: 'Spaces this memory is published to (e.g., ["the_void", "dogs"])',
+}
+```
+
+### 2. Update Collection Name Constant
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Add**:
+```typescript
+export const PUBLIC_COLLECTION_NAME = 'Memory_public';
+```
+
+### 3. Create ensurePublicCollection Function
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Add**:
+```typescript
+/**
+ * Ensure the unified public collection exists
+ */
+export async function ensurePublicCollection(
+  client: WeaviateClient
+): Promise<Collection<any>> {
+  const collectionName = PUBLIC_COLLECTION_NAME;
+  
+  const exists = await client.collections.exists(collectionName);
+  
+  if (!exists) {
+    await createSpaceCollection(client, 'public');
+  }
+  
+  return client.collections.get(collectionName);
+}
+```
+
+### 4. Keep Backward Compatibility
+
+**File**: `src/weaviate/space-schema.ts`
+
+- Keep `ensureSpaceCollection()` function for now
+- Keep `getSpaceCollectionName()` function for now
+- Add deprecation comments
+
+### 5. Update Schema Tests
+
+**File**: `src/weaviate/space-schema.spec.ts`
+
+**Add tests**:
+- Test `ensurePublicCollection()` creates `Memory_public`
+- Test `spaces` field is in schema
+- Test backward compatibility functions still work
+
+---
+
+## Verification
+
+- [ ] `spaces` field added to schema as `text[]`
+- [ ] `PUBLIC_COLLECTION_NAME` constant defined
+- [ ] `ensurePublicCollection()` function created
+- [ ] Backward compatibility maintained
+- [ ] Schema tests updated and passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/weaviate/space-schema.ts` - Add spaces field, public collection
+- `src/weaviate/space-schema.spec.ts` - Add tests
+
+---
+
+**Next Task**: Task 48 - Create Memory_public Collection

package/agent/tasks/task-48-create-memory-public-collection.md

@@ -0,0 +1,96 @@
+# Task 48: Create Memory_public Collection
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 1 hour
+**Dependencies**: Task 47
+**Status**: Not Started
+
+---
+
+## Objective
+
+Create the unified `Memory_public` Weaviate collection that will store all public space memories with the new `spaces` array field.
+
+---
+
+## Steps
+
+### 1. Update Collection Creation Logic
+
+**File**: `src/weaviate/space-schema.ts`
+
+**Modify `createSpaceCollection`**:
+```typescript
+async function createSpaceCollection(
+  client: WeaviateClient,
+  spaceId: string
+): Promise<void> {
+  // Handle 'public' as special case
+  const collectionName = spaceId === 'public' 
+    ? PUBLIC_COLLECTION_NAME 
+    : getSpaceCollectionName(spaceId);
+  
+  console.log(`[Weaviate] Creating space collection ${collectionName}...`);
+  
+  // ... rest of schema creation
+}
+```
+
+### 2. Test Collection Creation
+
+**File**: `src/weaviate/space-schema.spec.ts`
+
+**Add test**:
+```typescript
+it('should create Memory_public collection', async () => {
+  const collection = await ensurePublicCollection(mockClient);
+  
+  expect(mockClient.collections.exists).toHaveBeenCalledWith('Memory_public');
+  expect(mockClient.collections.create).toHaveBeenCalled();
+  expect(collection.name).toBe('Memory_public');
+});
+```
+
+### 3. Verify Schema Properties
+
+Ensure `Memory_public` has all required fields:
+- `spaces` array (new)
+- `space_id` (deprecated, for migration)
+- `author_id`
+- `attribution`
+- `published_at`
+- `discovery_count`
+- All standard memory fields
+
+### 4. Test with Actual Weaviate (Optional)
+
+If Weaviate instance available:
+```typescript
+// Manual test
+const client = getWeaviateClient();
+const collection = await ensurePublicCollection(client);
+console.log('Collection created:', collection.name);
+```
+
+---
+
+## Verification
+
+- [ ] `Memory_public` collection can be created
+- [ ] Collection has `spaces` array field
+- [ ] Collection has all required properties
+- [ ] `ensurePublicCollection()` works correctly
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/weaviate/space-schema.ts` - Update collection creation
+- `src/weaviate/space-schema.spec.ts` - Add tests
+
+---
+
+**Next Task**: Task 49 - Update remember_publish for Multi-Space