@prmichaelsen/remember-mcp 2.3.4 → 2.5.0

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

package/agent/tasks/task-52-update-remember-query-space.md

@@ -0,0 +1,142 @@
+# Task 52: Update remember_query_space for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 51
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `remember_query_space` tool to accept a `spaces` array parameter, enabling RAG queries across multiple spaces simultaneously.
+
+---
+
+## Steps
+
+### 1. Update Tool Input Schema
+
+**File**: `src/tools/query-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 query (e.g., ["the_void", "dogs"])',
+  minItems: 1,
+  default: ['the_void']
+}
+```
+
+### 2. Update handleQuerySpace Function
+
+**File**: `src/tools/query-space.ts`
+
+**Key Changes**:
+```typescript
+interface QuerySpaceArgs {
+  question: string;
+  spaces: string[];  // ✅ Changed from space: string
+  content_type?: string;
+  tags?: string[];
+  // ... other filters
+}
+
+export async function handleQuerySpace(
+  args: QuerySpaceArgs,
+  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'
+    }, 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);  // ✅ Query multiple spaces!
+  
+  // ... rest of RAG query logic
+}
+```
+
+### 3. Update Response Format
+
+**File**: `src/tools/query-space.ts`
+
+Include which spaces were queried:
+```typescript
+return JSON.stringify({
+  success: true,
+  spaces_queried: args.spaces,  // ✅ Show what was queried
+  question: args.question,
+  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/query-space.test.ts` (create if doesn't exist)
+
+**Add tests**:
+- Query single space
+- Query multiple spaces
+- Results from all spaces returned
+- Invalid space validation
+- RAG query works across spaces
+
+---
+
+## Verification
+
+- [ ] Tool accepts `spaces` array parameter
+- [ ] Can query single space: `spaces: ["the_void"]`
+- [ ] Can query multiple spaces: `spaces: ["the_void", "dogs"]`
+- [ ] Uses `containsAny` filter for spaces array
+- [ ] RAG results include memories from all requested spaces
+- [ ] Invalid spaces rejected
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/tools/query-space.ts` - Update for multi-space query
+
+## Files Created
+
+- `tests/unit/query-space.test.ts` - Add multi-space tests (if doesn't exist)
+
+---
+
+**Next Task**: Task 53 - Add Multi-Space Unit Tests