@prmichaelsen/remember-mcp 2.3.4 → 2.5.1

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

package/agent/tasks/task-49-update-remember-publish.md

@@ -0,0 +1,153 @@
+# Task 49: Update remember_publish for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 48
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `remember_publish` tool to accept a `spaces` array parameter, enabling users to publish memories to multiple spaces in a single operation.
+
+---
+
+## Steps
+
+### 1. Update Tool Input Schema
+
+**File**: `src/tools/publish.ts`
+
+**Change**:
+```typescript
+// Before
+target: {
+  type: 'string',
+  enum: SUPPORTED_SPACES,
+  default: 'the_void',
+}
+
+// After
+spaces: {
+  type: 'array',
+  items: {
+    type: 'string',
+    enum: SUPPORTED_SPACES
+  },
+  description: 'Spaces to publish to (e.g., ["the_void", "dogs"])',
+  minItems: 1,
+  default: ['the_void']
+}
+```
+
+### 2. Update Tool Description
+
+**File**: `src/tools/publish.ts`
+
+```typescript
+description: 'Publish a memory to one or more shared spaces. The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token. Use remember_confirm to execute.',
+```
+
+### 3. Update handlePublish Function
+
+**File**: `src/tools/publish.ts`
+
+**Changes**:
+- Accept `spaces: string[]` instead of `target: string`
+- Validate all spaces in array
+- Store `spaces` array in confirmation token payload
+
+```typescript
+interface PublishArgs {
+  memory_id: string;
+  spaces: string[];  // ✅ Changed from target: string
+  additional_tags?: string[];
+}
+
+export async function handlePublish(
+  args: PublishArgs,
+  userId: string
+): Promise<string> {
+  // Validate all 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(', ')}`,
+      context: {
+        invalid_spaces: invalidSpaces,
+        supported_spaces: SUPPORTED_SPACES
+      }
+    }, null, 2);
+  }
+  
+  // ... rest of validation
+  
+  // Store spaces array in payload
+  const payload = {
+    memory_id: args.memory_id,
+    spaces: args.spaces,  // ✅ Array
+    additional_tags: args.additional_tags || [],
+  };
+  
+  const { requestId, token } = await confirmationTokenService.createRequest(
+    userId,
+    'publish_memory',
+    payload,
+    undefined  // No single target_collection anymore
+  );
+  
+  return JSON.stringify({
+    success: true,
+    token,
+  }, null, 2);
+}
+```
+
+### 4. Add Backward Compatibility (Optional)
+
+Support both `target` and `spaces` during migration:
+```typescript
+// Accept both formats
+const spaces = args.spaces || (args.target ? [args.target] : ['the_void']);
+```
+
+### 5. Update Tests
+
+**File**: `tests/unit/publish.test.ts` (create if doesn't exist)
+
+**Add tests**:
+- Publish to single space
+- Publish to multiple spaces
+- Invalid space validation
+- Empty spaces array error
+
+---
+
+## Verification
+
+- [ ] Tool accepts `spaces` array parameter
+- [ ] Can publish to single space: `spaces: ["the_void"]`
+- [ ] Can publish to multiple spaces: `spaces: ["the_void", "dogs"]`
+- [ ] Invalid spaces rejected with clear error
+- [ ] Empty spaces array rejected
+- [ ] Token payload includes `spaces` array
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/tools/publish.ts` - Update to accept spaces array
+
+## Files Created
+
+- `tests/unit/publish.test.ts` - Add multi-space tests (if doesn't exist)
+
+---
+
+**Next Task**: Task 50 - Update remember_confirm for Multi-Space

package/agent/tasks/task-50-update-remember-confirm.md

@@ -0,0 +1,111 @@
+# Task 50: Update remember_confirm for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 49
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `remember_confirm` tool to handle multi-space publishing, storing memories in the unified `Memory_public` collection with the `spaces` array field.
+
+---
+
+## Steps
+
+### 1. Update executePublishMemory Function
+
+**File**: `src/tools/confirm.ts`
+
+**Key Changes**:
+```typescript
+async function executePublishMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string
+): Promise<string> {
+  // ... fetch original memory
+  
+  // Use unified public collection instead of per-space
+  const publicCollection = await ensurePublicCollection(weaviateClient);
+  
+  // Create published memory with spaces array
+  const publishedMemory = {
+    ...originalMemory.properties,
+    spaces: request.payload.spaces,  // ✅ Array from payload
+    author_id: userId,
+    published_at: new Date().toISOString(),
+    discovery_count: 0,
+    doc_type: 'space_memory',
+    attribution: 'user' as const,
+    tags: [...originalTags, ...additionalTags],
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    version: 1,
+  };
+  
+  // Insert into Memory_public
+  const result = await publicCollection.data.insert(publishedMemory as any);
+  
+  return JSON.stringify({
+    success: true,
+    space_memory_id: result,
+    spaces: request.payload.spaces  // ✅ Return spaces array
+  }, null, 2);
+}
+```
+
+### 2. Update Logging
+
+**File**: `src/tools/confirm.ts`
+
+```typescript
+console.log('[executePublishMemory] Inserting into Memory_public:', {
+  spaces: request.payload.spaces,  // ✅ Log array
+  memoryId: request.payload.memory_id,
+  spaceCount: request.payload.spaces.length,
+});
+```
+
+### 3. Handle Migration (Optional)
+
+Support old `target_collection` format during transition:
+```typescript
+const spaces = request.payload.spaces || 
+               (request.target_collection ? [request.target_collection] : ['the_void']);
+```
+
+### 4. Update Response Format
+
+Return spaces array in success response:
+```typescript
+{
+  "success": true,
+  "space_memory_id": "new-id",
+  "spaces": ["the_void", "dogs"]  // ✅ Show which spaces
+}
+```
+
+---
+
+## Verification
+
+- [ ] Uses `ensurePublicCollection()` instead of `ensureSpaceCollection()`
+- [ ] Stores `spaces` array in published memory
+- [ ] Memory inserted into `Memory_public` collection
+- [ ] Response includes `spaces` array
+- [ ] Logging shows multi-space publishing
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/tools/confirm.ts` - Update executePublishMemory
+
+---
+
+**Next Task**: Task 51 - Update remember_search_space for Multi-Space

package/agent/tasks/task-51-update-remember-search-space.md

@@ -0,0 +1,154 @@
+# Task 51: Update remember_search_space for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 3 hours
+**Dependencies**: Task 50
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `remember_search_space` tool to accept a `spaces` array parameter, enabling users to search multiple spaces in a single query.
+
+---
+
+## Steps
+
+### 1. Update Tool Input Schema
+
+**File**: `src/tools/search-space.ts`
+
+**Change**:
+```typescript
+// Before
+space: {
+  type: 'string',
+  enum: SUPPORTED_SPACES,
+  default: 'the_void'
+}
+
+// After
+spaces: {
+  type: 'array',
+  items: {
+    type: 'string',
+    enum: SUPPORTED_SPACES
+  },
+  description: 'Spaces to search (e.g., ["the_void", "dogs"])',
+  minItems: 1,
+  default: ['the_void']
+}
+```
+
+### 2. Update handleSearchSpace Function
+
+**File**: `src/tools/search-space.ts`
+
+**Key Changes**:
+```typescript
+interface SearchSpaceArgs {
+  query: string;
+  spaces: string[];  // ✅ Changed from space: string
+  content_type?: string;
+  tags?: string[];
+  // ... other filters
+}
+
+export async function handleSearchSpace(
+  args: SearchSpaceArgs,
+  userId: string
+): Promise<string> {
+  // Validate all 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(', ')}`
+    }, null, 2);
+  }
+  
+  // Use unified public collection
+  const publicCollection = await ensurePublicCollection(weaviateClient);
+  
+  // Build filter for spaces array
+  const spacesFilter = publicCollection.filter
+    .byProperty('spaces')
+    .containsAny(args.spaces);  // ✅ Search multiple spaces!
+  
+  // Combine with other filters
+  const filters = [spacesFilter, ...otherFilters];
+  const combinedFilter = Filters.and(...filters);
+  
+  // Execute search
+  const results = await publicCollection.query
+    .hybrid(args.query, { alpha: 0.5 })
+    .filter(combinedFilter)
+    .limit(args.limit || 10)
+    .offset(args.offset || 0);
+  
+  // ... format and return results
+}
+```
+
+### 3. Update Result Formatting
+
+**File**: `src/tools/search-space.ts`
+
+Include which spaces were searched:
+```typescript
+return JSON.stringify({
+  success: true,
+  spaces_searched: args.spaces,  // ✅ Show what was searched
+  results: formattedResults,
+  total: results.length
+}, null, 2);
+```
+
+### 4. Add Backward Compatibility (Optional)
+
+Support both `space` and `spaces` during migration:
+```typescript
+const spaces = args.spaces || (args.space ? [args.space] : ['the_void']);
+```
+
+### 5. Update Tests
+
+**File**: `tests/unit/search-space.test.ts` (create if doesn't exist)
+
+**Add tests**:
+- Search single space
+- Search multiple spaces
+- Results from all spaces returned
+- Invalid space validation
+- Empty spaces array error
+- Filter by spaces with containsAny
+
+---
+
+## Verification
+
+- [ ] Tool accepts `spaces` array parameter
+- [ ] Can search single space: `spaces: ["the_void"]`
+- [ ] Can search multiple spaces: `spaces: ["the_void", "dogs"]`
+- [ ] Uses `containsAny` filter for spaces array
+- [ ] Results include memories from all requested spaces
+- [ ] Invalid spaces rejected
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/tools/search-space.ts` - Update for multi-space search
+
+## Files Created
+
+- `tests/unit/search-space.test.ts` - Add multi-space tests (if doesn't exist)
+
+---
+
+**Next Task**: Task 52 - Update remember_query_space for Multi-Space