@prmichaelsen/remember-mcp 3.0.0 → 3.13.0

package/agent/tasks/milestone-14-memory-collection-v2/task-166-update-remember-publish.md

@@ -0,0 +1,191 @@
+# Task 166: Implement remember_publish Tool
+
+**Milestone**: Milestone 14 - Memory Collection Pattern v2
+**Estimated Time**: 6-8 hours
+**Dependencies**: [Task 165: Core Infrastructure Setup](task-165-core-infrastructure-setup.md)
+**Status**: Completed
+**Completed**: 2026-02-26
+
+---
+
+## Objective
+
+Implement the `remember_publish` tool to support multi-space and multi-group publication with composite IDs and tracking arrays.
+
+---
+
+## Steps
+
+### 1. Create Tool Schema
+
+**File**: `src/tools/remember-publish.ts`
+
+**Actions**:
+- Update input schema to accept `spaces` array (multiple spaces)
+- Update input schema to accept `groups` array (multiple groups)
+- Keep `memory_id` parameter (source memory ID)
+- Add optional `user_id` parameter (defaults to current user)
+- Update tool description to explain multi-publication
+
+**Expected Schema**:
+```typescript
+{
+  memory_id: string,
+  spaces?: string[],  // ["cooking", "recipes"]
+  groups?: string[],  // ["{group-id-1}", "{group-id-2}"]
+  user_id?: string    // Defaults to current user
+}
+```
+
+### 2. Implement Multi-Space Publication
+
+**Actions**:
+- Load source memory from `Memory_users_{userId}/{memory_id}`
+- Generate composite ID: `{userId}.{memory_id}`
+- For each space in `spaces` array:
+  - Check if memory already exists in `Memory_spaces_public` with composite ID
+  - If exists: Update `space_ids` array (add new space)
+  - If not exists: Create new memory with composite ID and `space_ids` array
+- Update source memory's `space_ids` array
+- Return success with published locations
+
+**Expected Behavior**:
+```typescript
+// Publish to multiple spaces
+remember_publish({
+  memory_id: "my-recipe",
+  spaces: ["cooking", "recipes"]
+})
+
+// Creates/updates:
+// 1. Memory_spaces_public/user123.my-recipe with space_ids=["cooking", "recipes"]
+// 2. Memory_users_user123/my-recipe with space_ids=["cooking", "recipes"]
+```
+
+### 3. Implement Multi-Group Publication
+
+**Actions**:
+- Load source memory from `Memory_users_{userId}/{memory_id}`
+- Generate composite ID: `{userId}.{memory_id}`
+- For each group in `groups` array:
+  - Check if memory already exists in `Memory_groups_{groupId}` with composite ID
+  - If exists: Update `group_ids` array (add new group)
+  - If not exists: Create new memory with composite ID and `group_ids` array
+- Update source memory's `group_ids` array
+- Return success with published locations
+
+**Expected Behavior**:
+```typescript
+// Publish to multiple groups
+remember_publish({
+  memory_id: "my-recipe",
+  groups: ["{foodie-group}", "{recipe-club}"]
+})
+
+// Creates/updates:
+// 1. Memory_groups_{foodie-group}/user123.my-recipe
+// 2. Memory_groups_{recipe-club}/user123.my-recipe
+// 3. Memory_users_user123/my-recipe with group_ids=["{foodie-group}", "{recipe-club}"]
+```
+
+### 4. Implement Dual Publication
+
+**Actions**:
+- Support publishing to both spaces and groups simultaneously
+- Ensure `space_ids` and `group_ids` arrays are synchronized across all copies
+- Handle partial failures gracefully (rollback on error)
+
+**Expected Behavior**:
+```typescript
+// Publish to both spaces and groups
+remember_publish({
+  memory_id: "my-recipe",
+  spaces: ["cooking"],
+  groups: ["{foodie-group}"]
+})
+
+// Creates/updates:
+// 1. Memory_spaces_public/user123.my-recipe with space_ids=["cooking"], group_ids=["{foodie-group}"]
+// 2. Memory_groups_{foodie-group}/user123.my-recipe with space_ids=["cooking"], group_ids=["{foodie-group}"]
+// 3. Memory_users_user123/my-recipe with space_ids=["cooking"], group_ids=["{foodie-group}"]
+```
+
+### 5. Add Error Handling
+
+**Actions**:
+- Validate source memory exists
+- Validate spaces and groups arrays are not empty
+- Validate user has permission to publish to spaces/groups
+- Handle Weaviate connection errors
+- Rollback on partial failure (transaction-like behavior)
+- Return clear error messages
+
+### 6. Write Integration Tests
+
+**File**: `tests/integration/remember-publish.test.ts`
+
+**Actions**:
+- Test single space publication
+- Test multi-space publication
+- Test single group publication
+- Test multi-group publication
+- Test dual publication (spaces + groups)
+- Test updating existing published memory
+- Test error cases (missing source, invalid IDs, etc.)
+- Test rollback on partial failure
+
+**Expected Output**: All tests passing
+
+---
+
+## Verification
+
+- [ ] Tool schema updated correctly
+- [ ] Multi-space publication works
+- [ ] Multi-group publication works
+- [ ] Dual publication works (spaces + groups)
+- [ ] Composite IDs generated correctly
+- [ ] Tracking arrays updated correctly
+- [ ] Source memory updated with publication locations
+- [ ] Error handling works correctly
+- [ ] Rollback works on partial failure
+- [ ] Integration tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Tool description updated in MCP manifest
+
+---
+
+## Expected Output
+
+### Files Modified
+- `src/tools/remember-publish-v2.ts` (~250 lines)
+
+### Files Created
+- `tests/integration/remember-publish.test.ts` (~200 lines)
+
+### Test Output
+```
+✓ Single space publication (3 tests)
+✓ Multi-space publication (4 tests)
+✓ Single group publication (3 tests)
+✓ Multi-group publication (4 tests)
+✓ Dual publication (5 tests)
+✓ Error handling (6 tests)
+
+Total: 25 tests passing
+```
+
+---
+
+## Notes
+
+- This is a breaking change from v1 (single space only)
+- Consider maintaining v1 compatibility layer temporarily
+- Composite IDs must be used for all published memories
+- Tracking arrays must be synchronized across all copies
+- Transaction-like behavior prevents partial failures
+- Clear error messages help debugging
+
+---
+
+**Next Task**: [Task 167: Update remember_retract Tool](task-167-update-remember-retract.md)

package/agent/tasks/milestone-14-memory-collection-v2/task-167-update-remember-retract.md

@@ -0,0 +1,186 @@
+# Task 167: Implement remember_retract Tool
+
+**Milestone**: Milestone 14 - Memory Collection Pattern v2
+**Estimated Time**: 4-6 hours
+**Dependencies**: [Task 165: Core Infrastructure Setup](task-165-core-infrastructure-setup.md), [Task 166: Implement remember_publish Tool](task-166-update-remember-publish.md)
+**Status**: Completed
+**Completed**: 2026-02-26
+
+---
+
+## Objective
+
+Implement the `remember_retract` tool to support selective retraction from specific spaces and groups, maintaining orphaned memories for historical reference.
+
+---
+
+## Steps
+
+### 1. Create Tool Schema
+
+**File**: `src/tools/remember-retract.ts`
+
+**Actions**:
+- Update input schema to accept `spaces` array (spaces to retract from)
+- Update input schema to accept `groups` array (groups to retract from)
+- Keep `memory_id` parameter (source memory ID)
+- Add optional `user_id` parameter (defaults to current user)
+- Update tool description to explain selective retraction
+
+**Expected Schema**:
+```typescript
+{
+  memory_id: string,
+  spaces?: string[],  // ["cooking"] - retract from these spaces
+  groups?: string[],  // ["{group-id}"] - retract from these groups
+  user_id?: string    // Defaults to current user
+}
+```
+
+### 2. Implement Selective Space Retraction
+
+**Actions**:
+- Load source memory from `Memory_users_{userId}/{memory_id}`
+- Generate composite ID: `{userId}.{memory_id}`
+- For each space in `spaces` array:
+  - Load memory from `Memory_spaces_public` with composite ID
+  - Remove space from `space_ids` array
+  - If `space_ids` becomes empty AND `group_ids` is empty: Keep memory (orphaned)
+  - If `space_ids` still has items OR `group_ids` has items: Update memory
+- Update source memory's `space_ids` array (remove retracted spaces)
+- Return success with retraction details
+
+**Expected Behavior**:
+```typescript
+// Retract from specific space
+remember_retract({
+  memory_id: "my-recipe",
+  spaces: ["cooking"]
+})
+
+// Updates:
+// 1. Memory_spaces_public/user123.my-recipe: space_ids=["recipes"] (removed "cooking")
+// 2. Memory_users_user123/my-recipe: space_ids=["recipes"]
+// If space_ids becomes empty, memory remains (orphaned)
+```
+
+### 3. Implement Selective Group Retraction
+
+**Actions**:
+- Load source memory from `Memory_users_{userId}/{memory_id}`
+- Generate composite ID: `{userId}.{memory_id}`
+- For each group in `groups` array:
+  - Load memory from `Memory_groups_{groupId}` with composite ID
+  - Remove group from `group_ids` array
+  - If `group_ids` becomes empty: Delete memory from this group collection
+- Update source memory's `group_ids` array (remove retracted groups)
+- Return success with retraction details
+
+**Expected Behavior**:
+```typescript
+// Retract from specific group
+remember_retract({
+  memory_id: "my-recipe",
+  groups: ["{foodie-group}"]
+})
+
+// Updates:
+// 1. Deletes Memory_groups_{foodie-group}/user123.my-recipe
+// 2. Memory_users_user123/my-recipe: group_ids=[] (removed group)
+```
+
+### 4. Implement Orphaned Memory Handling
+
+**Actions**:
+- When retracting from all spaces, keep memory in `Memory_spaces_public`
+- Mark memory as orphaned (empty `space_ids` and `group_ids`)
+- Add `retracted_at` timestamp
+- Keep for historical reference (can still be found by composite ID)
+
+**Expected Behavior**:
+```typescript
+// Retract from all spaces
+remember_retract({
+  memory_id: "my-recipe",
+  spaces: ["cooking", "recipes"]  // All spaces
+})
+
+// Result:
+// Memory_spaces_public/user123.my-recipe remains with:
+// - space_ids: []
+// - group_ids: []
+// - retracted_at: timestamp
+```
+
+### 5. Add Error Handling
+
+**Actions**:
+- Validate source memory exists
+- Validate spaces and groups arrays are not empty
+- Validate memory is actually published to specified spaces/groups
+- Handle Weaviate connection errors
+- Return clear error messages
+
+### 6. Write Integration Tests
+
+**File**: `tests/integration/remember-retract.test.ts`
+
+**Actions**:
+- Test single space retraction
+- Test multi-space retraction
+- Test single group retraction
+- Test multi-group retraction
+- Test orphaned memory creation
+- Test error cases (not published, invalid IDs, etc.)
+
+**Expected Output**: All tests passing
+
+---
+
+## Verification
+
+- [ ] Tool schema updated correctly
+- [ ] Selective space retraction works
+- [ ] Selective group retraction works
+- [ ] Orphaned memories handled correctly
+- [ ] Tracking arrays updated correctly
+- [ ] Source memory updated correctly
+- [ ] Error handling works correctly
+- [ ] Integration tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Tool description updated in MCP manifest
+
+---
+
+## Expected Output
+
+### Files Modified
+- `src/tools/remember-retract-v2.ts` (~200 lines)
+
+### Files Created
+- `tests/integration/remember-retract.test.ts` (~150 lines)
+
+### Test Output
+```
+✓ Single space retraction (3 tests)
+✓ Multi-space retraction (3 tests)
+✓ Single group retraction (3 tests)
+✓ Multi-group retraction (3 tests)
+✓ Orphaned memory handling (4 tests)
+✓ Error handling (4 tests)
+
+Total: 20 tests passing
+```
+
+---
+
+## Notes
+
+- Orphaned memories remain for historical reference
+- Group memories are deleted when retracted (not orphaned)
+- Space memories are orphaned when all spaces retracted
+- Clear distinction between space and group retraction behavior
+
+---
+
+**Next Task**: [Task 168: Implement remember_revise Tool](task-168-implement-remember-revise.md)

package/agent/tasks/milestone-14-memory-collection-v2/task-168-implement-remember-revise.md

@@ -0,0 +1,184 @@
+# Task 168: Implement remember_revise Tool
+
+**Milestone**: Milestone 14 - Memory Collection Pattern v2
+**Estimated Time**: 6-8 hours
+**Dependencies**: [Task 165: Core Infrastructure Setup](task-165-core-infrastructure-setup.md), [Task 166: Update remember_publish Tool](task-166-update-remember-publish.md)
+**Status**: Completed
+**Completed**: 2026-02-26
+
+---
+
+## Objective
+
+Implement the new `remember_revise` tool to synchronize content updates across all published copies of a memory (spaces and groups), maintaining revision history.
+
+---
+
+## Steps
+
+### 1. Create Tool Schema
+
+**File**: `src/tools/remember-revise.ts`
+
+**Actions**:
+- Create input schema with `memory_id` parameter
+- Add optional `user_id` parameter (defaults to current user)
+- Add tool description explaining revision synchronization
+- Register tool in MCP manifest
+
+**Expected Schema**:
+```typescript
+{
+  memory_id: string,
+  user_id?: string    // Defaults to current user
+}
+```
+
+### 2. Implement Content Synchronization
+
+**Actions**:
+- Load source memory from `Memory_users_{userId}/{memory_id}`
+- Get current content from source memory
+- Generate composite ID: `{userId}.{memory_id}`
+- Find all published locations from source memory's tracking arrays:
+  - `space_ids` → `Memory_spaces_public`
+  - `group_ids` → `Memory_groups_{groupId}`
+- For each published location:
+  - Load published memory
+  - Save current content to `revision_history` array
+  - Update content with source content
+  - Set `revised_at` timestamp
+- Return success with revision details
+
+**Expected Behavior**:
+```typescript
+// User updates source
+remember_update_memory({ id: "my-recipe", content: "Updated recipe" })
+
+// Revise all published versions
+remember_revise({ memory_id: "my-recipe" })
+
+// Updates:
+// 1. Memory_spaces_public/user123.my-recipe: content updated, old added to revision_history
+// 2. Memory_groups_{foodie-group}/user123.my-recipe: content updated, old added to revision_history
+// 3. Both get revised_at timestamp
+```
+
+### 3. Implement Revision History Management
+
+**Actions**:
+- Add old content to `revision_history` array before updating
+- Include timestamp with each revision
+- Limit revision history to last 10 versions (configurable)
+- Compress old revisions if needed
+
+**Expected Structure**:
+```typescript
+{
+  revision_history: [
+    { content: "Old content 1", revised_at: "2026-02-25T10:00:00Z" },
+    { content: "Old content 2", revised_at: "2026-02-26T14:30:00Z" }
+  ]
+}
+```
+
+### 4. Handle Partial Failures
+
+**Actions**:
+- Track which locations were successfully revised
+- Track which locations failed
+- Rollback on critical failures
+- Return detailed status for each location
+
+**Expected Behavior**:
+```typescript
+// Partial failure scenario
+remember_revise({ memory_id: "my-recipe" })
+
+// Returns:
+{
+  success: true,
+  revised: [
+    { location: "Memory_spaces_public", status: "success" },
+    { location: "Memory_groups_{foodie-group}", status: "success" },
+    { location: "Memory_groups_{recipe-club}", status: "failed", error: "Connection timeout" }
+  ],
+  warnings: ["Failed to revise 1 of 3 locations"]
+}
+```
+
+### 5. Add Error Handling
+
+**Actions**:
+- Validate source memory exists
+- Validate memory is published (has space_ids or group_ids)
+- Handle Weaviate connection errors
+- Handle missing published memories (orphaned references)
+- Return clear error messages
+
+### 6. Write Integration Tests
+
+**File**: `tests/integration/remember-revise.test.ts`
+
+**Actions**:
+- Test revision to single space
+- Test revision to multiple spaces
+- Test revision to single group
+- Test revision to multiple groups
+- Test revision to spaces + groups
+- Test revision history management
+- Test partial failure handling
+- Test error cases (not published, missing source, etc.)
+
+**Expected Output**: All tests passing
+
+---
+
+## Verification
+
+- [ ] Tool schema created correctly
+- [ ] Content synchronization works
+- [ ] Revision history managed correctly
+- [ ] All published copies updated
+- [ ] Timestamps set correctly
+- [ ] Partial failures handled gracefully
+- [ ] Error handling works correctly
+- [ ] Integration tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Tool registered in MCP manifest
+
+---
+
+## Expected Output
+
+### Files Created
+- `src/tools/remember-revise.ts` (~250 lines)
+- `tests/integration/remember-revise.test.ts` (~180 lines)
+
+### Test Output
+```
+✓ Single space revision (3 tests)
+✓ Multi-space revision (3 tests)
+✓ Single group revision (3 tests)
+✓ Multi-group revision (3 tests)
+✓ Dual revision (spaces + groups) (4 tests)
+✓ Revision history management (5 tests)
+✓ Partial failure handling (3 tests)
+✓ Error handling (4 tests)
+
+Total: 28 tests passing
+```
+
+---
+
+## Notes
+
+- This is a new tool (not in v1)
+- Critical for maintaining consistency across published copies
+- Revision history enables rollback if needed
+- Partial failures should not prevent successful revisions
+- Consider adding `remember_get_revision_history` tool in future
+
+---
+
+**Next Task**: [Task 169: Update remember_search_space Tool](task-169-update-remember-search-space.md)