@prmichaelsen/remember-mcp 2.5.2 → 2.6.2

package/agent/tasks/task-56-update-search-space-for-comments.md

@@ -0,0 +1,192 @@
+# Task 56: Update remember_search_space for Comments
+
+**Milestone**: M12 (Comment System - Phase 1)
+**Estimated Time**: 2 hours
+**Dependencies**: Task 55 (Add Comment Fields)
+**Status**: Not Started
+
+---
+
+## Objective
+
+Add `include_comments` parameter to `remember_search_space` tool to control whether comments are included in search results. Default behavior excludes comments to keep discovery clean.
+
+---
+
+## Steps
+
+### 1. Update Tool Schema ([`src/tools/search-space.ts`](../../src/tools/search-space.ts))
+
+Add new parameter to `inputSchema`:
+
+```typescript
+include_comments: {
+  type: 'boolean',
+  description: 'Include comments in search results (default: false)',
+  default: false
+}
+```
+
+**Location**: Add after existing parameters, before `required` array
+
+### 2. Update TypeScript Interface
+
+Add to `SearchSpaceArgs` interface:
+
+```typescript
+interface SearchSpaceArgs {
+  // ... existing fields
+  include_comments?: boolean;
+}
+```
+
+### 3. Update Filter Logic
+
+Modify the search logic to exclude comments by default:
+
+```typescript
+// After building other filters, add content type filter
+if (!args.include_comments) {
+  // Exclude comments by default
+  filterList.push(
+    publicCollection.filter.byProperty('type').notEqual('comment')
+  );
+}
+```
+
+**Location**: Add before executing the query, after other filters are built
+
+### 4. Update Tool Description
+
+Update the tool description to mention comment filtering:
+
+```typescript
+description: 'Search shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions.',
+```
+
+### 5. Test the Changes
+
+Create test cases for comment filtering:
+
+```typescript
+// Test 1: Default behavior (exclude comments)
+const results1 = await handleSearchSpace({
+  spaces: ['the_void'],
+  query: 'test'
+  // include_comments not specified = false
+}, userId);
+// Should not include type: "comment"
+
+// Test 2: Include comments
+const results2 = await handleSearchSpace({
+  spaces: ['the_void'],
+  query: 'test',
+  include_comments: true
+}, userId);
+// Should include type: "comment"
+```
+
+---
+
+## Verification
+
+- [ ] `include_comments` parameter added to schema
+- [ ] Parameter has correct type (boolean)
+- [ ] Parameter has correct default (false)
+- [ ] Parameter has clear description
+- [ ] TypeScript interface updated
+- [ ] Filter logic excludes comments by default
+- [ ] Filter logic includes comments when `include_comments: true`
+- [ ] Tool description updated
+- [ ] TypeScript compiles without errors
+- [ ] All existing tests passing
+- [ ] New comment filtering tests passing
+
+---
+
+## Implementation Notes
+
+### Default Behavior (Exclude Comments)
+
+**Why**: Keep discovery experience clean
+- Users searching for "hiking trails" want memories, not 100 comments
+- Comments are opt-in via `include_comments: true`
+- Follows positive flag pattern (explicit opt-in)
+
+**Example**:
+```typescript
+remember_search_space({
+  spaces: ["the_void"],
+  query: "hiking trails"
+  // include_comments: false (default)
+})
+// Returns: 10 memories (no comments)
+```
+
+### Opt-In Comments
+
+**When to use**: Viewing a specific thread or searching within discussions
+
+**Example**:
+```typescript
+remember_search_space({
+  spaces: ["the_void"],
+  query: "hiking trails",
+  include_comments: true  // ✅ Include comments
+})
+// Returns: 10 memories + 50 comments = 60 results
+```
+
+### Fetching Entire Thread
+
+**Use case**: Get all comments for a specific memory
+
+**Example**:
+```typescript
+remember_search_space({
+  spaces: ["the_void"],
+  query: "",  // Empty query = get all
+  content_type: "comment",  // Only comments
+  // Add filter for thread_root_id in Weaviate query
+  limit: 100
+})
+// Returns: All comments in the thread
+```
+
+**Note**: This requires adding support for filtering by `thread_root_id` in the Weaviate query. Consider adding a `thread_id` parameter in a future enhancement.
+
+### Filter Implementation
+
+**Weaviate v3 API**:
+```typescript
+// Exclude comments (default)
+publicCollection.filter.byProperty('type').notEqual('comment')
+
+// Or use content_type filter if already implemented
+if (args.content_type) {
+  // Existing content type filter
+} else if (!args.include_comments) {
+  // Exclude comments
+  filterList.push(
+    publicCollection.filter.byProperty('type').notEqual('comment')
+  );
+}
+```
+
+---
+
+## Files Modified
+
+- [`src/tools/search-space.ts`](../../src/tools/search-space.ts) - Add `include_comments` parameter and filter logic
+
+---
+
+## Files Created
+
+None (tool update only)
+
+---
+
+## Next Task
+
+Task 57: Update remember_query_space for Comments

package/agent/tasks/task-57-update-query-space-for-comments.md

@@ -0,0 +1,167 @@
+# Task 57: Update remember_query_space for Comments
+
+**Milestone**: M12 (Comment System - Phase 1)
+**Estimated Time**: 1 hour
+**Dependencies**: Task 56 (Update search_space)
+**Status**: Not Started
+
+---
+
+## Objective
+
+Add `include_comments` parameter to `remember_query_space` tool to control whether comments are included in RAG query results. Default behavior excludes comments to keep answers focused on original content.
+
+---
+
+## Steps
+
+### 1. Update Tool Schema ([`src/tools/query-space.ts`](../../src/tools/query-space.ts))
+
+Add new parameter to `inputSchema`:
+
+```typescript
+include_comments: {
+  type: 'boolean',
+  description: 'Include comments in query results (default: false)',
+  default: false
+}
+```
+
+**Location**: Add after existing parameters, before `required` array
+
+### 2. Update TypeScript Interface
+
+Add to `QuerySpaceArgs` interface:
+
+```typescript
+interface QuerySpaceArgs {
+  // ... existing fields
+  include_comments?: boolean;
+}
+```
+
+### 3. Update Filter Logic
+
+Modify the query logic to exclude comments by default (same as search_space):
+
+```typescript
+// After building other filters, add content type filter
+if (!args.include_comments) {
+  // Exclude comments by default
+  filterList.push(
+    publicCollection.filter.byProperty('type').notEqual('comment')
+  );
+}
+```
+
+**Location**: Add before executing the query, after other filters are built
+
+### 4. Update Tool Description
+
+Update the tool description to mention comment filtering:
+
+```typescript
+description: 'Ask natural language questions about memories in shared spaces. By default, excludes comments to focus on original content. Set include_comments: true to include discussions in answers.',
+```
+
+### 5. Test the Changes
+
+Reuse test pattern from search_space:
+
+```typescript
+// Test 1: Default behavior (exclude comments)
+const results1 = await handleQuerySpace({
+  question: 'What are good hiking trails?',
+  spaces: ['the_void']
+  // include_comments not specified = false
+}, userId);
+// Should not include type: "comment" in results
+
+// Test 2: Include comments
+const results2 = await handleQuerySpace({
+  question: 'What are good hiking trails?',
+  spaces: ['the_void'],
+  include_comments: true
+}, userId);
+// Should include type: "comment" in results
+```
+
+---
+
+## Verification
+
+- [ ] `include_comments` parameter added to schema
+- [ ] Parameter has correct type (boolean)
+- [ ] Parameter has correct default (false)
+- [ ] Parameter has clear description
+- [ ] TypeScript interface updated
+- [ ] Filter logic excludes comments by default
+- [ ] Filter logic includes comments when `include_comments: true`
+- [ ] Tool description updated
+- [ ] TypeScript compiles without errors
+- [ ] All existing tests passing
+- [ ] New comment filtering tests passing
+
+---
+
+## Implementation Notes
+
+### Why Exclude Comments by Default?
+
+**RAG queries focus on original content**:
+- Question: "What are good hiking trails?"
+- Want: Original memories about trails
+- Don't want: 100 comments saying "I agree!" or "Thanks!"
+
+**Comments add noise to RAG answers**:
+- Comments are often short, low-information
+- Original memories have richer content
+- Better to query memories, then show comments separately
+
+### When to Include Comments?
+
+**Use case**: Searching within discussions
+
+**Example**:
+```typescript
+remember_query_space({
+  question: "What did people say about Bear Lake Trail?",
+  spaces: ["the_void"],
+  include_comments: true  // ✅ Include discussions
+})
+// Returns: Memory + all comments mentioning Bear Lake
+```
+
+### Implementation Pattern
+
+**Same as search_space**:
+- Both tools use identical filtering logic
+- Consistent user experience
+- Reuse filter implementation
+
+```typescript
+// Shared filter logic (consider extracting to utility)
+if (!args.include_comments) {
+  filterList.push(
+    publicCollection.filter.byProperty('type').notEqual('comment')
+  );
+}
+```
+
+---
+
+## Files Modified
+
+- [`src/tools/query-space.ts`](../../src/tools/query-space.ts) - Add `include_comments` parameter and filter logic
+
+---
+
+## Files Created
+
+None (tool update only)
+
+---
+
+## Next Task
+
+Task 58: Add Comment Unit Tests

package/agent/tasks/task-58-add-comment-unit-tests.md

@@ -0,0 +1,255 @@
+# Task 58: Add Comment Unit Tests
+
+**Milestone**: M12 (Comment System - Phase 1)
+**Estimated Time**: 3 hours
+**Dependencies**: Tasks 55-57 (Schema and tool updates)
+**Status**: Not Started
+
+---
+
+## Objective
+
+Create comprehensive unit tests for comment functionality, including schema validation, comment filtering, thread queries, and edge cases like infinite nesting and per-space moderation.
+
+---
+
+## Steps
+
+### 1. Test Schema Fields ([`tests/unit/schema.test.ts`](../../tests/unit/schema.test.ts))
+
+Add tests for new comment fields:
+
+```typescript
+describe('Comment Fields', () => {
+  it('should have parent_id field', () => {
+    const schema = getMemorySchema();
+    const parentIdField = schema.properties.find(p => p.name === 'parent_id');
+    expect(parentIdField).toBeDefined();
+    expect(parentIdField.dataType).toBe('text');
+  });
+
+  it('should have thread_root_id field', () => {
+    const schema = getMemorySchema();
+    const threadField = schema.properties.find(p => p.name === 'thread_root_id');
+    expect(threadField).toBeDefined();
+    expect(threadField.dataType).toBe('text');
+  });
+
+  it('should have moderation_flags field', () => {
+    const schema = getMemorySchema();
+    const flagsField = schema.properties.find(p => p.name === 'moderation_flags');
+    expect(flagsField).toBeDefined();
+    expect(flagsField.dataType).toContain('text');  // text[]
+  });
+});
+```
+
+### 2. Test Space Schema Fields ([`tests/unit/space-schema.test.ts`](../../tests/unit/space-schema.test.ts))
+
+Add tests for public collection comment fields:
+
+```typescript
+describe('Comment Fields in Public Collection', () => {
+  it('should have parent_id field in Memory_public', async () => {
+    const collection = await ensurePublicCollection(mockClient);
+    const schema = await collection.config.get();
+    const parentIdField = schema.properties.find(p => p.name === 'parent_id');
+    expect(parentIdField).toBeDefined();
+  });
+
+  it('should have thread_root_id field in Memory_public', async () => {
+    const collection = await ensurePublicCollection(mockClient);
+    const schema = await collection.config.get();
+    const threadField = schema.properties.find(p => p.name === 'thread_root_id');
+    expect(threadField).toBeDefined();
+  });
+
+  it('should have moderation_flags field in Memory_public', async () => {
+    const collection = await ensurePublicCollection(mockClient);
+    const schema = await collection.config.get();
+    const flagsField = schema.properties.find(p => p.name === 'moderation_flags');
+    expect(flagsField).toBeDefined();
+  });
+});
+```
+
+### 3. Test Comment Filtering ([`tests/unit/search-space.test.ts`](../../tests/unit/search-space.test.ts))
+
+Add tests for `include_comments` parameter:
+
+```typescript
+describe('Comment Filtering', () => {
+  it('should exclude comments by default', async () => {
+    const result = await handleSearchSpace({
+      spaces: ['the_void'],
+      query: 'test'
+      // include_comments not specified
+    }, 'user123');
+    
+    // Verify filter was applied to exclude comments
+    expect(mockFilter.notEqual).toHaveBeenCalledWith('comment');
+  });
+
+  it('should include comments when include_comments: true', async () => {
+    const result = await handleSearchSpace({
+      spaces: ['the_void'],
+      query: 'test',
+      include_comments: true
+    }, 'user123');
+    
+    // Verify no comment filter was applied
+    expect(mockFilter.notEqual).not.toHaveBeenCalledWith('comment');
+  });
+
+  it('should filter by content_type: comment', async () => {
+    const result = await handleSearchSpace({
+      spaces: ['the_void'],
+      query: 'test',
+      content_type: 'comment'
+    }, 'user123');
+    
+    // Verify filter for comments only
+    expect(mockFilter.equal).toHaveBeenCalledWith('comment');
+  });
+});
+```
+
+### 4. Test Query Space Comment Filtering ([`tests/unit/query-space.test.ts`](../../tests/unit/query-space.test.ts))
+
+Add similar tests for query_space:
+
+```typescript
+describe('Comment Filtering in Query', () => {
+  it('should exclude comments by default', async () => {
+    const result = await handleQuerySpace({
+      question: 'What are good hiking trails?',
+      spaces: ['the_void']
+      // include_comments not specified
+    }, 'user123');
+    
+    // Verify filter was applied
+    expect(mockFilter.notEqual).toHaveBeenCalledWith('comment');
+  });
+
+  it('should include comments when include_comments: true', async () => {
+    const result = await handleQuerySpace({
+      question: 'What are good hiking trails?',
+      spaces: ['the_void'],
+      include_comments: true
+    }, 'user123');
+    
+    // Verify no comment filter
+    expect(mockFilter.notEqual).not.toHaveBeenCalledWith('comment');
+  });
+});
+```
+
+### 5. Test Edge Cases
+
+Create tests for edge cases:
+
+```typescript
+describe('Comment Edge Cases', () => {
+  it('should support infinite nesting', () => {
+    // Create deeply nested comment structure
+    const comments = [
+      { id: '1', parent_id: 'memory', thread_root_id: 'memory' },
+      { id: '2', parent_id: '1', thread_root_id: 'memory' },
+      { id: '3', parent_id: '2', thread_root_id: 'memory' },
+      { id: '4', parent_id: '3', thread_root_id: 'memory' },
+      { id: '5', parent_id: '4', thread_root_id: 'memory' },
+      // ... up to 100 levels
+    ];
+    
+    // Verify all have same thread_root_id
+    comments.forEach(c => {
+      expect(c.thread_root_id).toBe('memory');
+    });
+  });
+
+  it('should support per-space moderation flags', () => {
+    const comment = {
+      id: 'comment123',
+      moderation_flags: [
+        'the_void:hidden',
+        'dogs:spam',
+        'cats:flagged'
+      ]
+    };
+    
+    // Verify flag format
+    comment.moderation_flags.forEach(flag => {
+      expect(flag).toMatch(/^[a-z_]+:(hidden|spam|flagged)$/);
+    });
+  });
+
+  it('should handle empty moderation_flags array', () => {
+    const comment = {
+      id: 'comment123',
+      moderation_flags: []
+    };
+    
+    expect(Array.isArray(comment.moderation_flags)).toBe(true);
+    expect(comment.moderation_flags.length).toBe(0);
+  });
+});
+```
+
+### 6. Run All Tests
+
+```bash
+npm test
+```
+
+**Expected**: All tests passing, including new comment tests
+
+---
+
+## Verification
+
+- [ ] Schema field tests passing
+- [ ] Space schema field tests passing
+- [ ] Comment filtering tests passing (search_space)
+- [ ] Comment filtering tests passing (query_space)
+- [ ] Edge case tests passing
+- [ ] All existing tests still passing
+- [ ] Test coverage maintained or improved
+- [ ] TypeScript compiles without errors
+- [ ] No test failures or warnings
+
+---
+
+## Test Coverage Goals
+
+**Minimum Coverage**:
+- Schema fields: 100%
+- Comment filtering: 100%
+- Edge cases: 80%
+
+**Focus Areas**:
+- Default behavior (exclude comments)
+- Opt-in behavior (include comments)
+- Content type filtering
+- Moderation flags format
+- Infinite nesting support
+
+---
+
+## Files Modified
+
+- [`tests/unit/schema.test.ts`](../../tests/unit/schema.test.ts) - Add comment field tests
+- [`tests/unit/space-schema.test.ts`](../../tests/unit/space-schema.test.ts) - Add public collection tests
+- [`tests/unit/search-space.test.ts`](../../tests/unit/search-space.test.ts) - Add filtering tests
+- [`tests/unit/query-space.test.ts`](../../tests/unit/query-space.test.ts) - Add filtering tests
+
+---
+
+## Files Created
+
+None (test updates only)
+
+---
+
+## Next Task
+
+Task 59: Update Documentation for Comments