@prmichaelsen/remember-mcp 2.2.1 → 2.3.1

package/agent/tasks/task-44-implement-remember-retract.md

@@ -0,0 +1,263 @@
+# Task 44: Implement remember_retract Tool
+
+**Milestone**: M11 - Shared Spaces Enhancements (Future)
+**Estimated Time**: 3 hours
+**Dependencies**: M10 (Shared Spaces complete)
+**Status**: Not Started
+
+---
+
+## Objective
+
+Implement the `remember_retract` tool that allows users to unpublish (remove) their memories from shared spaces. Uses the same token-based confirmation pattern as `remember_publish`.
+
+---
+
+## Steps
+
+### 1. Create Tool File
+
+Create `src/tools/retract.ts` with tool definition and handler.
+
+**Actions**:
+- Import required dependencies (token service, Weaviate client, types)
+- Define tool schema with MCP Tool interface
+- Create handler function signature
+- Export both tool definition and handler
+
+**Expected Outcome**: Tool file structure created
+
+### 2. Define Tool Schema
+
+Create MCP tool definition for remember_retract.
+
+**Actions**:
+- Set tool name: `remember_retract`
+- Write clear description for LLM
+- Define input schema with properties:
+  - `space_memory_id` (required): ID of memory in shared space
+  - `space` (required): Space ID (enum: ['the_void'])
+- Add helpful descriptions
+
+**Expected Outcome**: Tool schema complete
+
+### 3. Implement Memory Validation
+
+Verify the space memory exists and user is the author.
+
+**Actions**:
+- Get space Weaviate collection
+- Fetch space memory by ID
+- Check if memory exists
+- Verify `author_id` matches userId (not space_id)
+- Return detailed error if validation fails
+- Include context in error response
+
+**Expected Outcome**: Memory ownership verified
+
+### 4. Create Confirmation Payload
+
+Build the payload to store with the token.
+
+**Actions**:
+- Extract space_memory_id from args
+- Extract space from args
+- Store only IDs (not full content)
+- Keep payload minimal
+
+**Expected Outcome**: Payload structure defined
+
+### 5. Generate Confirmation Token
+
+Use token service to create confirmation request.
+
+**Actions**:
+- Call `confirmationTokenService.createRequest()`
+- Pass userId, action='retract_memory', payload, space
+- Receive requestId and token
+- Handle any errors from token service
+
+**Expected Outcome**: Token generated successfully
+
+### 6. Format Success Response
+
+Return token to agent (minimal response).
+
+**Actions**:
+- Create response object with success flag
+- Include token
+- Keep response minimal (agent already knows memory details)
+- Format as JSON string
+
+**Expected Outcome**: Clear response format
+
+### 7. Update handleConfirm
+
+Add retract action executor to confirm tool.
+
+**Actions**:
+- Open `src/tools/confirm.ts`
+- Add `executeRetractMemory` function
+- Validate token and fetch space memory
+- Verify author_id matches userId
+- Delete memory from space collection
+- Return success with minimal response
+
+**Expected Outcome**: Retract action can be executed
+
+### 8. Implement Error Handling
+
+Handle all error cases gracefully.
+
+**Actions**:
+- Memory not found error
+- Permission denied error (not the author)
+- Invalid space ID error
+- Token service errors
+- Weaviate connection errors
+- Use `handleToolError` utility
+- Include context in all errors
+
+**Expected Outcome**: Comprehensive error handling
+
+### 9. Add Tool to Server
+
+Register tool in both server files.
+
+**Actions**:
+- Import tool in `src/server.ts`
+- Add to tools list in ListToolsRequestSchema handler
+- Add to CallToolRequestSchema handler
+- Repeat for `src/server-factory.ts`
+- Test tool registration
+
+**Expected Outcome**: Tool available in MCP server
+
+### 10. Create Unit Tests
+
+Test the retract tool thoroughly.
+
+**Actions**:
+- Create `src/tools/retract.spec.ts`
+- Test successful token generation
+- Test memory not found error
+- Test permission denied error (wrong author)
+- Test invalid space ID
+- Mock Weaviate and token service
+- Verify response format
+
+**Expected Outcome**: All tests passing
+
+---
+
+## Verification
+
+- [ ] `src/tools/retract.ts` created
+- [ ] Tool schema defined with correct parameters
+- [ ] Memory validation implemented (checks author_id)
+- [ ] Token generation working
+- [ ] Success response formatted correctly
+- [ ] executeRetractMemory added to confirm.ts
+- [ ] Error handling comprehensive
+- [ ] Tool registered in server.ts
+- [ ] Tool registered in server-factory.ts
+- [ ] Unit tests created and passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Tool Schema
+
+```typescript
+export const retractTool = {
+  name: 'remember_retract',
+  description: 'Unpublish a memory from a shared space. The memory will be REMOVED from the shared collection. Generates a confirmation token. Use remember_confirm to execute.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      space_memory_id: {
+        type: 'string',
+        description: 'ID of the memory in the shared space to retract'
+      },
+      space: {
+        type: 'string',
+        description: 'Which space to retract from (snake_case ID)',
+        enum: ['the_void'],
+        default: 'the_void'
+      }
+    },
+    required: ['space_memory_id', 'space']
+  }
+};
+```
+
+---
+
+## Response Format
+
+```json
+{
+  "success": true,
+  "token": "550e8400-e29b-41d4-a716-446655440000"
+}
+```
+
+---
+
+## executeRetractMemory Implementation
+
+```typescript
+async function executeRetractMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string
+): Promise<string> {
+  // Fetch space memory
+  const weaviateClient = getWeaviateClient();
+  const spaceCollection = await ensureSpaceCollection(
+    weaviateClient,
+    request.target_collection || 'the_void'
+  );
+
+  const spaceMemory = await spaceCollection.query.fetchObjectById(
+    request.payload.space_memory_id
+  );
+
+  if (!spaceMemory) {
+    return JSON.stringify({
+      success: false,
+      error: 'Memory not found',
+      message: `Space memory ${request.payload.space_memory_id} no longer exists`,
+    }, null, 2);
+  }
+
+  // Verify user is the author
+  if (spaceMemory.properties.author_id !== userId) {
+    return JSON.stringify({
+      success: false,
+      error: 'Permission denied',
+      message: 'You can only retract your own published memories',
+    }, null, 2);
+  }
+
+  // Delete from space collection
+  await spaceCollection.data.deleteById(request.payload.space_memory_id);
+
+  return JSON.stringify({
+    success: true,
+  }, null, 2);
+}
+```
+
+---
+
+## Related Files
+
+- Design: [`agent/design/publish-tools-confirmation-flow.md`](../design/publish-tools-confirmation-flow.md)
+- Token Service: [`src/services/confirmation-token.service.ts`](../../src/services/confirmation-token.service.ts)
+- Confirm Tool: [`src/tools/confirm.ts`](../../src/tools/confirm.ts)
+- Space Schema: [`src/weaviate/space-schema.ts`](../../src/weaviate/space-schema.ts)
+
+---
+
+**Next Task**: TBD - Part of future milestone for shared spaces enhancements

package/agent/tasks/task-45-fix-publish-false-success-bug.md

@@ -0,0 +1,230 @@
+# Task 45: Fix remember_publish False Success Bug
+
+**Milestone**: M10 - Shared Spaces & Confirmation Flow (Bug Fix)
+**Estimated Time**: 2 hours
+**Dependencies**: M10 (Tasks 34-40)
+**Status**: Not Started
+**Priority**: HIGH - Critical bug, false positive
+
+---
+
+## Objective
+
+Fix the `remember_publish` and `remember_confirm` tools which report `success: true` but do not actually publish memories to The Void. The operation is completely non-functional - no write occurs, no duplication, no error thrown.
+
+---
+
+## Problem Statement
+
+### Symptoms
+- `remember_confirm` returns `success: true`
+- Database shows `Memory_the_void` collection has 0 objects
+- Memory only exists in personal collection (not copied)
+- No error is thrown
+- False positive misleads users and agents
+
+### Impact
+- Core feature completely non-functional
+- False success responses worse than errors (misleading)
+- Breaks agent reliability and user trust
+- No workaround available
+
+---
+
+## Steps
+
+### 1. Verify Collection Exists
+
+Check if `Memory_the_void` collection exists in Weaviate.
+
+**Actions**:
+- Query Weaviate for collection list
+- Check if `Memory_the_void` exists
+- Verify collection schema if it exists
+- Check write permissions
+
+**Expected Outcome**: Collection status determined
+
+### 2. Review executePublishMemory Function
+
+Examine the publish execution logic in confirm.ts.
+
+**Actions**:
+- Open [`src/tools/confirm.ts`](../../src/tools/confirm.ts)
+- Review `executePublishMemory` function
+- Check if `targetCollection.data.insert()` is called
+- Verify result is returned correctly
+- Check error handling
+
+**Expected Outcome**: Code logic understood
+
+### 3. Add Debug Logging
+
+Add logging to track execution flow.
+
+**Actions**:
+- Add log before collection fetch
+- Add log before memory fetch
+- Add log before insert operation
+- Add log after insert with result
+- Log any caught errors
+
+**Expected Outcome**: Execution flow visible
+
+### 4. Test Locally
+
+Run publish workflow with logging enabled.
+
+**Actions**:
+- Create test memory
+- Call remember_publish
+- Call remember_confirm with token
+- Check logs for execution flow
+- Verify if insert is called
+- Check Weaviate for result
+
+**Expected Outcome**: Root cause identified
+
+### 5. Fix the Bug
+
+Implement the fix based on root cause.
+
+**Possible Fixes**:
+- **If collection doesn't exist**: Ensure `ensureSpaceCollection()` creates it
+- **If insert not called**: Fix logic flow to reach insert
+- **If insert fails silently**: Add proper error handling
+- **If permissions issue**: Fix Weaviate configuration
+- **If wrong collection**: Fix collection name generation
+
+**Expected Outcome**: Bug fixed
+
+### 6. Verify Fix
+
+Test that publish actually works.
+
+**Actions**:
+- Create test memory
+- Publish to The Void
+- Confirm publication
+- Query `Memory_the_void` collection
+- Verify memory exists in space
+- Verify original memory unchanged
+- Test search_space finds it
+
+**Expected Outcome**: Publish works correctly
+
+### 7. Add Integration Test
+
+Create test for full publish workflow.
+
+**Actions**:
+- Create integration test file
+- Test: create → publish → confirm → verify in space
+- Test: search_space finds published memory
+- Test: original memory still in personal collection
+- Requires live Weaviate instance
+
+**Expected Outcome**: Integration test passing
+
+### 8. Update Error Handling
+
+Ensure errors are caught and reported.
+
+**Actions**:
+- Add try-catch around insert operation
+- Return detailed error if insert fails
+- Include Weaviate error details
+- Test error scenarios
+
+**Expected Outcome**: Errors reported accurately
+
+### 9. Test Edge Cases
+
+Verify fix handles edge cases.
+
+**Actions**:
+- Test with large memory
+- Test with memory that has relationships
+- Test with memory that has special characters
+- Test concurrent publishes
+- Test expired token
+
+**Expected Outcome**: All edge cases handled
+
+### 10. Update Documentation
+
+Document the fix.
+
+**Actions**:
+- Add to CHANGELOG (patch version)
+- Update any affected documentation
+- Note in progress.yaml
+- Document root cause for future reference
+
+**Expected Outcome**: Fix documented
+
+---
+
+## Verification
+
+- [ ] Root cause identified
+- [ ] Bug fixed in code
+- [ ] Memory actually written to `Memory_the_void`
+- [ ] Published memory discoverable via search_space
+- [ ] Original memory unchanged in personal collection
+- [ ] Error handling accurate (no false positives)
+- [ ] Integration test created
+- [ ] All tests passing
+- [ ] TypeScript compiles
+- [ ] Build successful
+- [ ] Changes committed and pushed
+
+---
+
+## Investigation Checklist
+
+- [ ] Check if `Memory_the_void` collection exists
+- [ ] Verify `ensureSpaceCollection()` is called
+- [ ] Verify `targetCollection.data.insert()` is called
+- [ ] Check if insert returns a result
+- [ ] Verify result is used in response
+- [ ] Check server logs for errors
+- [ ] Test with actual Weaviate instance
+- [ ] Verify Weaviate write permissions
+
+---
+
+## Expected Fix
+
+The bug is likely in [`src/tools/confirm.ts`](../../src/tools/confirm.ts) in the `executePublishMemory` function. The insert operation may not be executing or may be failing silently.
+
+**Likely Issue**: Missing await, incorrect API usage, or silent error
+
+**Expected Code**:
+```typescript
+const result = await targetCollection.data.insert({
+  properties: publishedMemory as any,
+});
+
+// Verify result
+if (!result) {
+  throw new Error('Failed to insert memory into space collection');
+}
+
+return JSON.stringify({
+  success: true,
+  space_memory_id: result,
+}, null, 2);
+```
+
+---
+
+## Related Files
+
+- Confirm Tool: [`src/tools/confirm.ts`](../../src/tools/confirm.ts)
+- Space Schema: [`src/weaviate/space-schema.ts`](../../src/weaviate/space-schema.ts)
+- Design: [`agent/design/publish-tools-confirmation-flow.md`](../design/publish-tools-confirmation-flow.md)
+
+---
+
+**Next Task**: Investigate and fix immediately - blocks shared spaces feature

package/dist/llm/types.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=types.d.ts.map