@prmichaelsen/remember-mcp 2.6.7 → 2.6.9

package/agent/tasks/task-66-initialize-comment-fields-in-tools.md

@@ -0,0 +1,294 @@
+# Task 66: Support All Schema Fields in Create/Update Tools
+
+**Milestone**: M12 (Comment System / Schema Completeness)
+**Estimated Time**: 2 hours
+**Dependencies**: Task 65 (migration script)
+**Status**: Not Started
+**Priority**: High
+
+---
+
+## Objective
+
+Ensure all create and update tools (both personal and space tools) support ALL schema fields in their input schemas and properly initialize/update them. This includes comment fields and any other fields that may be missing from tool schemas.
+
+---
+
+## Context
+
+**Current Problem**:
+- New memories created via `remember_create_memory` don't have comment fields
+- Space memories created via `remember_publish` may be missing fields
+- Update tools may not support all schema fields
+- After migration (Task 65), old memories will have these fields
+- This creates inconsistency between old and new memories
+
+**Missing Fields**:
+- Comment fields: `parent_id`, `thread_root_id`, `moderation_flags`
+- Potentially other fields not in tool schemas
+
+**Affected Tools**:
+- `remember_create_memory` - Personal memory creation
+- `remember_update_memory` - Personal memory updates
+- `remember_publish` / `remember_confirm` - Space memory creation (via executePublishMemory)
+
+**Impact**:
+- New memories missing fields
+- Inconsistent schema across memories
+- Potential query/filter issues
+- Space memories may be incomplete
+
+---
+
+## Steps
+
+### 1. Update remember_create_memory Tool Schema
+
+Add comment fields to input schema:
+
+```typescript
+// src/tools/create-memory.ts
+
+export const createMemoryTool: Tool = {
+  name: 'remember_create_memory',
+  description: '...',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      // ... existing properties ...
+      
+      // Comment/threading fields (optional)
+      parent_id: {
+        type: 'string',
+        description: 'ID of parent memory or comment (for threading). Leave null for top-level memories.',
+      },
+      thread_root_id: {
+        type: 'string',
+        description: 'Root memory ID for thread. Leave null for top-level memories.',
+      },
+      moderation_flags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}"). Usually empty.',
+        default: [],
+      },
+    },
+    required: ['type', 'content'], // parent_id, thread_root_id, moderation_flags are optional
+  },
+};
+```
+
+### 2. Initialize Comment Fields in handleCreateMemory
+
+Ensure fields are always initialized:
+
+```typescript
+// src/tools/create-memory.ts - in handleCreateMemory function
+
+const memory: Memory = {
+  // ... existing fields ...
+  
+  // Comment/threading fields (initialize to defaults)
+  parent_id: args.parent_id || null,
+  thread_root_id: args.thread_root_id || null,
+  moderation_flags: args.moderation_flags || [],
+  
+  // ... rest of fields ...
+};
+```
+
+### 3. Update remember_update_memory Tool Schema
+
+Add comment fields to update schema:
+
+```typescript
+// src/tools/update-memory.ts
+
+export const updateMemoryTool: Tool = {
+  name: 'remember_update_memory',
+  description: '...',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      // ... existing properties ...
+      
+      // Comment/threading fields (optional)
+      parent_id: {
+        type: 'string',
+        description: 'Update parent ID (for threading)',
+      },
+      thread_root_id: {
+        type: 'string',
+        description: 'Update thread root ID',
+      },
+      moderation_flags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Update moderation flags',
+      },
+    },
+    required: ['memory_id'],
+  },
+};
+```
+
+### 4. Support Comment Fields in handleUpdateMemory
+
+Allow updating comment fields:
+
+```typescript
+// src/tools/update-memory.ts - in handleUpdateMemory function
+
+const updates: Partial<Memory> = {};
+
+// ... existing field updates ...
+
+// Comment/threading fields
+if (args.parent_id !== undefined) {
+  updates.parent_id = args.parent_id;
+}
+if (args.thread_root_id !== undefined) {
+  updates.thread_root_id = args.thread_root_id;
+}
+if (args.moderation_flags !== undefined) {
+  updates.moderation_flags = args.moderation_flags;
+}
+```
+
+### 5. Update Memory Type Interface
+
+Ensure TypeScript types include comment fields:
+
+```typescript
+// src/types/memory.ts
+
+export interface Memory {
+  // ... existing fields ...
+  
+  // Comment/threading fields
+  parent_id?: string | null;
+  thread_root_id?: string | null;
+  moderation_flags?: string[];
+  
+  // ... rest of fields ...
+}
+```
+
+### 6. Test New Memory Creation
+
+Verify new memories have comment fields:
+
+```bash
+# Create a regular memory
+remember_create_memory({
+  type: "note",
+  content: "Test memory"
+})
+
+# Verify it has:
+# - parent_id: null
+# - thread_root_id: null
+# - moderation_flags: []
+
+# Create a comment
+remember_create_memory({
+  type: "comment",
+  content: "Great post!",
+  parent_id: "memory123",
+  thread_root_id: "memory123"
+})
+
+# Verify it has the parent/thread IDs set
+```
+
+---
+
+## Verification
+
+- [ ] `remember_create_memory` input schema includes comment fields
+- [ ] `handleCreateMemory` initializes comment fields to defaults
+- [ ] `remember_update_memory` input schema includes comment fields
+- [ ] `handleUpdateMemory` supports updating comment fields
+- [ ] `Memory` type interface includes comment fields
+- [ ] New memories created with `parent_id: null`
+- [ ] New memories created with `thread_root_id: null`
+- [ ] New memories created with `moderation_flags: []`
+- [ ] Can create comments with parent_id set
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+- [ ] All tests passing
+
+---
+
+## Expected Output
+
+**New Regular Memory**:
+```json
+{
+  "id": "new-memory-id",
+  "type": "note",
+  "content": "Test content",
+  "parent_id": null,
+  "thread_root_id": null,
+  "moderation_flags": [],
+  // ... other fields
+}
+```
+
+**New Comment**:
+```json
+{
+  "id": "comment-id",
+  "type": "comment",
+  "content": "Great post!",
+  "parent_id": "memory123",
+  "thread_root_id": "memory123",
+  "moderation_flags": [],
+  // ... other fields
+}
+```
+
+---
+
+## Common Issues and Solutions
+
+### Issue 1: TypeScript errors about new fields
+
+**Cause**: Memory type not updated
+**Solution**: Add fields to Memory interface in src/types/memory.ts
+
+### Issue 2: Fields not showing in created memories
+
+**Cause**: Not initialized in handleCreateMemory
+**Solution**: Ensure defaults are set (null for IDs, [] for flags)
+
+### Issue 3: Can't update comment fields
+
+**Cause**: handleUpdateMemory doesn't support them
+**Solution**: Add field update logic
+
+---
+
+## Resources
+
+- [Memory Type Definition](../src/types/memory.ts)
+- [remember_create_memory Tool](../src/tools/create-memory.ts)
+- [remember_update_memory Tool](../src/tools/update-memory.ts)
+- [Comment System Design](../design/comment-memory-type.md)
+
+---
+
+## Notes
+
+- This ensures consistency between old (migrated) and new memories
+- Comment fields are optional in input schema
+- Defaults: `parent_id: null`, `thread_root_id: null`, `moderation_flags: []`
+- Only comments should have non-null parent_id/thread_root_id
+- Regular memories always have null for these fields
+- This completes the comment system foundation
+
+---
+
+**Status**: Not Started
+**Recommendation**: Implement after Task 65 migration completes
+**Priority**: High - Ensures schema consistency for all new memories

package/agent/tasks/task-67-migrate-memory-public-schema.md

@@ -0,0 +1,226 @@
+# Task 67: Migrate Memory_public Collection Schema
+
+**Milestone**: M12 (Comment System)
+**Estimated Time**: 1 hour
+**Dependencies**: Task 55, Task 66
+**Status**: Not Started
+**Priority**: High
+
+---
+
+## Objective
+
+Update the existing `Memory_public` collection in Weaviate Cloud to include the missing comment fields (`parent_id` and `thread_root_id`). Currently, only `moderation_flags` exists in the production schema.
+
+---
+
+## Problem
+
+The `Memory_public` collection was created before comment fields were added to the schema. Weaviate doesn't support adding properties to existing collections, so we need to migrate the data.
+
+**Current State** (Production):
+- ✅ `moderation_flags` field exists
+- ❌ `parent_id` field missing
+- ❌ `thread_root_id` field missing
+
+**Expected State** (Code):
+- ✅ All three fields defined in `src/weaviate/space-schema.ts` (lines 261-275)
+
+---
+
+## Impact
+
+**Without Migration**:
+- Cannot create comments in shared spaces
+- Cannot thread discussions
+- Published memories missing comment fields
+- Schema mismatch between code and production
+
+**With Migration**:
+- Full comment system functionality in shared spaces
+- Threaded discussions work correctly
+- Schema matches code definition
+
+---
+
+## Migration Options
+
+### Option 1: Delete and Recreate (DESTRUCTIVE)
+
+**Steps**:
+1. Backup all data from `Memory_public`
+2. Delete `Memory_public` collection
+3. Recreate with updated schema (automatic via `ensurePublicCollection`)
+4. Restore data with new fields initialized
+
+**Pros**:
+- Clean schema
+- Simple process
+
+**Cons**:
+- ⚠️ **LOSES ALL DATA** if backup fails
+- Downtime during migration
+- Risky for production
+
+### Option 2: Create New Collection and Migrate (SAFE)
+
+**Steps**:
+1. Create `Memory_public_v2` with updated schema
+2. Copy all data from `Memory_public` to `Memory_public_v2`
+3. Initialize comment fields: `parent_id: null`, `thread_root_id: null`, `moderation_flags: []`
+4. Test `Memory_public_v2` thoroughly
+5. Update code to use `Memory_public_v2`
+6. Delete old `Memory_public` after verification
+
+**Pros**:
+- ✅ Zero data loss
+- ✅ Can rollback if issues
+- ✅ Test before switching
+
+**Cons**:
+- More complex
+- Temporary storage duplication
+
+### Option 3: Live with Current Schema (NOT RECOMMENDED)
+
+**Steps**:
+- Do nothing
+- Comment system only works for personal memories
+- Shared spaces don't support comments
+
+**Pros**:
+- No migration needed
+
+**Cons**:
+- ❌ Incomplete feature
+- ❌ Schema mismatch
+- ❌ Technical debt
+
+---
+
+## Recommended Approach: Option 2 (Safe Migration)
+
+### Step 1: Create Backup Collection
+
+```typescript
+// Create Memory_public_v2 with full schema
+const client = getWeaviateClient();
+await client.collections.create({
+  name: 'Memory_public_v2',
+  // ... full schema from space-schema.ts including comment fields
+});
+```
+
+### Step 2: Migrate Data
+
+```typescript
+// Fetch all objects from Memory_public
+const oldCollection = client.collections.get('Memory_public');
+const objects = await oldCollection.query.fetchObjects({ limit: 10000 });
+
+// Insert into Memory_public_v2 with comment fields
+const newCollection = client.collections.get('Memory_public_v2');
+for (const obj of objects.objects) {
+  await newCollection.data.insert({
+    ...obj.properties,
+    parent_id: null,           // Initialize to null
+    thread_root_id: null,      // Initialize to null
+    moderation_flags: obj.properties.moderation_flags || [], // Preserve existing
+  });
+}
+```
+
+### Step 3: Update Code
+
+```typescript
+// src/weaviate/space-schema.ts
+export const PUBLIC_COLLECTION_NAME = 'Memory_public_v2'; // Changed from 'Memory_public'
+```
+
+### Step 4: Verify and Cleanup
+
+```bash
+# Test the new collection
+# Verify all data migrated correctly
+# Check comment fields exist
+
+# After verification (wait 24-48 hours):
+# Delete old Memory_public collection
+```
+
+---
+
+## Verification
+
+- [ ] `Memory_public_v2` collection created with full schema
+- [ ] All data migrated from `Memory_public`
+- [ ] Comment fields present: `parent_id`, `thread_root_id`, `moderation_flags`
+- [ ] All existing memories have `parent_id: null`, `thread_root_id: null`
+- [ ] `moderation_flags` preserved from original data
+- [ ] Code updated to use `Memory_public_v2`
+- [ ] All tests passing
+- [ ] Can create comments in shared spaces
+- [ ] Can publish memories with comment fields
+- [ ] Old `Memory_public` collection deleted (after verification period)
+
+---
+
+## Rollback Plan
+
+If issues occur:
+
+1. **Immediate Rollback**:
+   ```typescript
+   export const PUBLIC_COLLECTION_NAME = 'Memory_public'; // Revert to old
+   ```
+
+2. **Keep Both Collections**:
+   - Old collection still exists
+   - Can switch back instantly
+   - No data loss
+
+3. **After Verification**:
+   - Only delete old collection after 24-48 hours
+   - Ensure new collection works correctly
+
+---
+
+## Alternative: Manual Schema Update (If Supported)
+
+**Note**: Weaviate typically doesn't support adding properties to existing collections. Check Weaviate documentation for your version to see if schema evolution is supported.
+
+If supported:
+```bash
+# Use Weaviate API to add properties
+# This is version-dependent and may not be available
+```
+
+---
+
+## Production Checklist
+
+- [ ] Backup current `Memory_public` data
+- [ ] Create `Memory_public_v2` with full schema
+- [ ] Migrate all data with comment fields initialized
+- [ ] Test new collection thoroughly
+- [ ] Update `PUBLIC_COLLECTION_NAME` constant
+- [ ] Deploy updated code
+- [ ] Verify in production
+- [ ] Monitor for 24-48 hours
+- [ ] Delete old `Memory_public` collection
+
+---
+
+## Notes
+
+- This migration is required for comment system to work in shared spaces
+- Personal memory collections (`Memory_{user_id}`) don't need migration if created after Task 55
+- Old personal collections may also need migration (separate task)
+- Consider running migration during low-traffic period
+- Document migration in CHANGELOG.md
+
+---
+
+**Status**: Not Started
+**Recommendation**: Execute Option 2 (safe migration) during next deployment window
+**Priority**: High - Blocks comment system in shared spaces

package/dist/constants/content-types.d.ts

@@ -30,7 +30,7 @@ export declare const CONTENT_TYPE_CATEGORIES: {
     readonly communication: readonly ["email", "conversation", "meeting", "person"];
     readonly content: readonly ["article", "webpage", "social", "presentation", "spreadsheet", "pdf"];
     readonly media: readonly ["image", "video", "audio", "transcript"];
-    readonly creative: readonly ["song", "screenplay", "recipe", "idea", "quote"];
+    readonly creative: readonly ["song", "screenplay", "recipe", "idea", "quote", "poetry"];
     readonly personal: readonly ["journal", "memory", "event"];
     readonly organizational: readonly ["bookmark", "form", "location"];
     readonly business: readonly ["invoice", "contract"];

package/dist/server-factory.js

@@ -981,6 +981,7 @@ var CONTENT_TYPES = [
   "recipe",
   "idea",
   "quote",
+  "poetry",
   // Personal
   "journal",
   "memory",
@@ -1197,6 +1198,13 @@ var CONTENT_TYPE_METADATA = {
     examples: ["Quotes", "Excerpts", "Highlights", "Citations"],
     common_fields: ["author", "source"]
   },
+  poetry: {
+    name: "poetry",
+    category: "creative",
+    description: "Poems and poetic content",
+    examples: ["Poems", "Verses", "Haiku", "Sonnets", "Free verse"],
+    common_fields: ["author", "form", "theme"]
+  },
   // Personal
   journal: {
     name: "journal",
@@ -1391,6 +1399,20 @@ var createMemoryTool = {
         type: "boolean",
         description: "Skip automatic template suggestion",
         default: false
+      },
+      parent_id: {
+        type: "string",
+        description: "ID of parent memory or comment (for threading). Leave null for top-level memories."
+      },
+      thread_root_id: {
+        type: "string",
+        description: "Root memory ID for thread. Leave null for top-level memories."
+      },
+      moderation_flags: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}"). Usually empty.',
+        default: []
       }
     },
     required: ["content"]
@@ -1452,7 +1474,11 @@ async function handleCreateMemory(args, userId, context) {
       structured_content: args.structured_content,
       // Computed weight
       base_weight: args.weight ?? 0.5,
-      computed_weight: args.weight ?? 0.5
+      computed_weight: args.weight ?? 0.5,
+      // Comment/threading fields (initialize to defaults)
+      parent_id: args.parent_id ?? null,
+      thread_root_id: args.thread_root_id ?? null,
+      moderation_flags: args.moderation_flags ?? []
     };
     const result = await collection.data.insert({
       properties: memory
@@ -1889,6 +1915,19 @@ var updateMemoryTool = {
       structured_content: {
         type: "object",
         description: "Updated structured content"
+      },
+      parent_id: {
+        type: "string",
+        description: "Update parent ID (for threading)"
+      },
+      thread_root_id: {
+        type: "string",
+        description: "Update thread root ID"
+      },
+      moderation_flags: {
+        type: "array",
+        items: { type: "string" },
+        description: "Update moderation flags"
       }
     },
     required: ["memory_id"]
@@ -1901,7 +1940,7 @@ async function handleUpdateMemory(args, userId) {
     let existingMemory;
     try {
       existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ["user_id", "doc_type", "version", "type", "weight", "base_weight"]
+        returnProperties: ["user_id", "doc_type", "version"]
       });
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);
@@ -1968,6 +2007,18 @@ async function handleUpdateMemory(args, userId) {
       updates.structured_content = args.structured_content;
       updatedFields.push("structured_content");
     }
+    if (args.parent_id !== void 0) {
+      updates.parent_id = args.parent_id;
+      updatedFields.push("parent_id");
+    }
+    if (args.thread_root_id !== void 0) {
+      updates.thread_root_id = args.thread_root_id;
+      updatedFields.push("thread_root_id");
+    }
+    if (args.moderation_flags !== void 0) {
+      updates.moderation_flags = args.moderation_flags;
+      updatedFields.push("moderation_flags");
+    }
     if (updatedFields.length === 0) {
       throw new Error("No fields provided for update. At least one field must be specified.");
     }