@prmichaelsen/remember-mcp 2.5.2 → 2.6.1

package/CHANGELOG.md

@@ -5,6 +5,101 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.6.1] - 2026-02-16
+
+### 🔧 Improved
+
+- **Standardized Structured Logging**: Replaced all direct console calls with structured logger
+  - Replaced 54 console.log/error/warn calls across 8 files
+  - All logs now use structured JSON format with proper severity levels
+  - Logs respect LOG_LEVEL environment variable for filtering
+  - Better Cloud Run log aggregation and filtering
+  - Consistent context objects with relevant identifiers
+
+### 📝 Changed
+
+- Updated files with structured logging:
+  - `src/services/confirmation-token.service.ts` - 11 console calls replaced
+  - `src/tools/publish.ts` - 7 console calls replaced
+  - `src/tools/confirm.ts` - 11 console calls replaced
+  - `src/weaviate/client.ts` - 7 console calls replaced
+  - `src/weaviate/schema.ts` - 4 console calls replaced
+  - `src/weaviate/space-schema.ts` - 2 console calls replaced
+  - `src/firestore/init.ts` - 6 console calls replaced
+  - `src/config.ts` - 1 console call replaced
+
+### 🎯 Benefits
+
+- Log level filtering now works correctly (debug/info/warn/error)
+- Structured JSON logs for cloud environments
+- Consistent formatting across all services
+- Better integration with Cloud Logging filters
+- Easier to search and filter logs in production
+
+---
+
+## [2.6.0] - 2026-02-16
+
+### ✨ Added
+
+- **Comment System (Phase 1)**: Threaded discussions in shared spaces
+  - Added 3 schema fields: `parent_id`, `thread_root_id`, `moderation_flags`
+  - Comments support infinite nesting (no depth limit)
+  - Per-space moderation flags (format: `"{space_id}:{flag_type}"`)
+  - Zero new tools required - reuses existing `remember_create_memory`
+
+- **Comment Filtering**: Clean discovery experience
+  - Added `include_comments` parameter to `remember_search_space` (default: false)
+  - Added `include_comments` parameter to `remember_query_space` (default: false)
+  - Comments excluded from search by default for cleaner results
+  - Opt-in via `include_comments: true` to include discussions
+
+### 🔧 Changed
+
+- **Search behavior**: `remember_search_space` now excludes comments by default
+- **Query behavior**: `remember_query_space` now excludes comments by default
+- Tool descriptions updated to mention comment filtering
+
+### 📚 Documentation
+
+- Created Milestone 12: Comment System (Phase 1)
+- Created Tasks 55-59 for comment implementation
+- Updated design document with comment system architecture
+
+### 🎯 Usage
+
+```typescript
+// Create a comment
+remember_create_memory({
+  type: "comment",
+  content: "Great post!",
+  parent_id: "memory123",
+  thread_root_id: "memory123",
+  spaces: ["the_void"]
+})
+
+// Search without comments (default)
+remember_search_space({
+  spaces: ["the_void"],
+  query: "hiking"
+})
+
+// Search with comments (opt-in)
+remember_search_space({
+  spaces: ["the_void"],
+  query: "hiking",
+  include_comments: true
+})
+```
+
+### ⚠️ Notes
+
+- Backward compatible - no breaking changes
+- Comments are opt-in for search/query
+- Future phases will add voting, moderation tools, and notifications
+
+---
+
 ## [2.4.1] - 2026-02-16
 
 ### 🐛 Fixed

package/agent/milestones/milestone-12-comment-system.md

@@ -0,0 +1,239 @@
+# Milestone 12: Comment System (Phase 1 - Basic Comments)
+
+**Goal**: Enable threaded discussions in shared spaces using existing content type
+**Duration**: 1 week
+**Dependencies**: M11 (Unified Public Collection)
+**Status**: Not Started
+
+---
+
+## Overview
+
+Implement basic comment functionality for shared spaces using the existing `comment` content type. This milestone requires **zero new tools** - we'll extend the Weaviate schema with 3 new fields and add an `include_comments` parameter to existing search tools.
+
+**Key Innovation**: Reuse `remember_create_memory` with `type: "comment"` instead of creating new tools. This keeps the API surface small while enabling rich threaded discussions.
+
+---
+
+## Deliverables
+
+### 1. Schema Updates (3 new fields)
+- Add `parent_id` field (text) - ID of parent memory or comment
+- Add `thread_root_id` field (text) - Root memory ID for thread queries
+- Add `moderation_flags` field (text[]) - Per-space moderation flags
+
+### 2. Search Tool Updates (2 tools)
+- Update `remember_search_space` - Add `include_comments` parameter (default: false)
+- Update `remember_query_space` - Add `include_comments` parameter (default: false)
+
+### 3. Documentation Updates
+- Update design document with implementation details
+- Add comment examples to README
+- Document comment creation workflow
+- Add API examples for threaded discussions
+
+### 4. Testing
+- Unit tests for comment filtering
+- Unit tests for thread queries
+- Integration tests for comment workflows
+- Test infinite nesting support
+
+---
+
+## Success Criteria
+
+- [ ] Schema has 3 new fields: `parent_id`, `thread_root_id`, `moderation_flags`
+- [ ] Can create comments using `remember_create_memory` with `type: "comment"`
+- [ ] Comments have `parent_id` and `thread_root_id` populated
+- [ ] `remember_search_space` excludes comments by default
+- [ ] `remember_search_space` includes comments when `include_comments: true`
+- [ ] `remember_query_space` excludes comments by default
+- [ ] `remember_query_space` includes comments when `include_comments: true`
+- [ ] Can fetch entire thread by filtering on `thread_root_id`
+- [ ] Comments support infinite nesting (no depth limit)
+- [ ] Moderation flags are per-space (array field)
+- [ ] All existing tests still passing
+- [ ] New comment tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+- [ ] Documentation updated with examples
+
+---
+
+## Key Files to Modify
+
+```
+src/
+├── weaviate/
+│   ├── schema.ts                    # Add 3 new fields to schema
+│   └── space-schema.ts              # Add 3 new fields to public collection
+└── tools/
+    ├── search-space.ts              # Add include_comments parameter
+    └── query-space.ts               # Add include_comments parameter
+
+tests/
+└── unit/
+    ├── schema.test.ts               # Test new fields
+    ├── space-schema.test.ts         # Test new fields in public collection
+    ├── search-space.test.ts         # Test comment filtering
+    └── query-space.test.ts          # Test comment filtering
+
+agent/
+└── design/
+    └── comment-memory-type.md       # Update with implementation notes
+```
+
+---
+
+## Implementation Tasks
+
+See individual task documents:
+- Task 55: Add Comment Fields to Weaviate Schema
+- Task 56: Update remember_search_space for Comments
+- Task 57: Update remember_query_space for Comments
+- Task 58: Add Comment Unit Tests
+- Task 59: Update Documentation for Comments
+
+---
+
+## Architecture Notes
+
+### Zero New Tools Required
+
+**Create comment** (use existing tool):
+```typescript
+remember_create_memory({
+  type: "comment",              // ✅ Existing content type!
+  content: "Great post!",
+  parent_id: "memory123",       // ✅ New field
+  thread_root_id: "memory123",  // ✅ New field
+  spaces: ["the_void"]          // ✅ Inherited from parent
+})
+```
+
+**Fetch thread** (use existing search):
+```typescript
+remember_search_space({
+  spaces: ["the_void"],
+  query: "",
+  content_type: "comment",
+  // Filter by thread_root_id in Weaviate
+  limit: 100
+})
+```
+
+**Search without comments** (default behavior):
+```typescript
+remember_search_space({
+  spaces: ["the_void"],
+  query: "hiking trails"
+  // include_comments: false (default)
+})
+// Returns only memories, not comments
+```
+
+**Search with comments** (opt-in):
+```typescript
+remember_search_space({
+  spaces: ["the_void"],
+  query: "hiking trails",
+  include_comments: true  // ✅ Include comments in results
+})
+// Returns memories + comments
+```
+
+### Schema Changes
+
+**New Fields**:
+```typescript
+{
+  name: 'parent_id',
+  dataType: 'text' as any,
+  description: 'ID of parent memory or comment (for threading)'
+},
+{
+  name: 'thread_root_id',
+  dataType: 'text' as any,
+  description: 'Root memory ID for fetching entire thread'
+},
+{
+  name: 'moderation_flags',
+  dataType: 'text[]' as any,
+  description: 'Per-space moderation flags (e.g., ["the_void:hidden", "dogs:spam"])'
+}
+```
+
+### Moderation Flags (Per-Space)
+
+**Format**: `"{space_id}:{flag_type}"`
+
+**Examples**:
+- `"the_void:hidden"` - Hidden in The Void space
+- `"dogs:spam"` - Marked as spam in Dogs space
+- `"cats:flagged"` - Flagged for review in Cats space
+
+**Why per-space?**: A comment might be inappropriate in one space but fine in another. Moderators manage their own spaces independently.
+
+### Infinite Nesting Support
+
+**No depth limit**: Comments can nest infinitely
+- `parent_id` points to immediate parent
+- `thread_root_id` always points to root memory
+- UI builds tree structure from flat list
+
+**Example**:
+```
+Memory (root)
+├─ Comment 1 (parent_id: memory_id)
+│  ├─ Comment 2 (parent_id: comment1_id)
+│  │  └─ Comment 3 (parent_id: comment2_id)
+│  │     └─ Comment 4 (parent_id: comment3_id)
+│  │        └─ ... (infinite nesting)
+│  └─ Comment 5 (parent_id: comment1_id)
+└─ Comment 6 (parent_id: memory_id)
+```
+
+All comments have `thread_root_id: memory_id` for efficient thread fetching.
+
+---
+
+## Testing Strategy
+
+1. **Unit Tests**: Schema fields, filtering logic
+2. **Integration Tests**: Full comment workflow
+3. **Performance Tests**: Large threads (1000+ comments)
+4. **Edge Cases**: Infinite nesting, moderation flags
+
+---
+
+## Future Phases
+
+**Phase 2: Engagement (v2.7.0)** - Deferred
+- Voting system (requires ACL)
+- Sort by popularity
+- Vote tracking in Firestore
+
+**Phase 3: Moderation (v2.8.0)** - Deferred
+- Moderator tools (requires ACL)
+- Auto-hide spam
+- Moderator dashboard
+
+**Phase 4: Notifications (v2.9.0)** - Deferred
+- Notify authors of comments
+- Email/push notifications
+- Notification preferences
+
+---
+
+## Breaking Changes
+
+**None** - This is a backward-compatible addition:
+- Existing tools continue to work unchanged
+- New fields are optional
+- Default behavior (exclude comments) maintains current UX
+- Opt-in via `include_comments: true`
+
+---
+
+**Next Milestone**: M13 - Comment Engagement (Voting & Popularity)
+**Blockers**: None (builds on M11)

package/agent/tasks/task-55-add-comment-fields-to-schema.md

@@ -0,0 +1,171 @@
+# Task 55: Add Comment Fields to Weaviate Schema
+
+**Milestone**: M12 (Comment System - Phase 1)
+**Estimated Time**: 2 hours
+**Dependencies**: M11 (Unified Public Collection)
+**Status**: Not Started
+
+---
+
+## Objective
+
+Add 3 new fields to the Weaviate schema to support threaded comments: `parent_id`, `thread_root_id`, and `moderation_flags`. These fields enable infinite nesting, efficient thread queries, and per-space moderation.
+
+---
+
+## Steps
+
+### 1. Update Memory Schema ([`src/weaviate/schema.ts`](../../src/weaviate/schema.ts))
+
+Add 3 new properties to the Memory collection schema:
+
+```typescript
+{
+  name: 'parent_id',
+  dataType: 'text' as any,
+  description: 'ID of parent memory or comment (for threading)',
+},
+{
+  name: 'thread_root_id',
+  dataType: 'text' as any,
+  description: 'Root memory ID for fetching entire thread',
+},
+{
+  name: 'moderation_flags',
+  dataType: 'text[]' as any,
+  description: 'Per-space moderation flags (format: "{space_id}:{flag_type}")',
+}
+```
+
+**Location**: Add after existing properties, before the closing bracket
+
+### 2. Update Space Schema ([`src/weaviate/space-schema.ts`](../../src/weaviate/space-schema.ts))
+
+Add the same 3 properties to the public collection schema:
+
+```typescript
+{
+  name: 'parent_id',
+  dataType: 'text' as any,
+  description: 'ID of parent memory or comment (for threading)',
+},
+{
+  name: 'thread_root_id',
+  dataType: 'text' as any,
+  description: 'Root memory ID for fetching entire thread',
+},
+{
+  name: 'moderation_flags',
+  dataType: 'text[]' as any,
+  description: 'Per-space moderation flags (format: "{space_id}:{flag_type}")',
+}
+```
+
+**Location**: Add to `createSpaceCollection` function's properties array
+
+### 3. Verify Schema Updates
+
+**Check**:
+- Both schemas have all 3 new fields
+- Field names match exactly
+- Data types are correct (`text` for IDs, `text[]` for flags)
+- Descriptions are clear and consistent
+
+### 4. Test Schema Creation
+
+Run existing tests to ensure schema creation still works:
+
+```bash
+npm test -- schema.test.ts
+npm test -- space-schema.test.ts
+```
+
+**Expected**: All existing tests pass, no errors
+
+---
+
+## Verification
+
+- [ ] `parent_id` field added to both schemas
+- [ ] `thread_root_id` field added to both schemas
+- [ ] `moderation_flags` field added to both schemas
+- [ ] Field data types are correct
+- [ ] Descriptions are clear
+- [ ] TypeScript compiles without errors
+- [ ] All existing schema tests passing
+- [ ] No breaking changes to existing functionality
+
+---
+
+## Implementation Notes
+
+### Field Purposes
+
+**`parent_id`**:
+- Points to immediate parent (memory or comment)
+- Enables infinite nesting
+- Used by UI to build tree structure
+- Optional (null for root memories)
+
+**`thread_root_id`**:
+- Always points to root memory
+- Enables efficient "get all comments in thread" queries
+- Same as `parent_id` for direct replies to memories
+- Optional (null for root memories)
+
+**`moderation_flags`**:
+- Array of strings in format `"{space_id}:{flag_type}"`
+- Enables per-space moderation
+- Examples: `["the_void:hidden", "dogs:spam"]`
+- Empty array by default
+
+### Example Comment
+
+```typescript
+{
+  id: "comment123",
+  type: "comment",
+  content: "Great post!",
+  parent_id: "memory456",        // ✅ New field
+  thread_root_id: "memory456",   // ✅ New field
+  moderation_flags: [],          // ✅ New field
+  spaces: ["the_void"],
+  author_id: "user789",
+  // ... other standard fields
+}
+```
+
+### Example Nested Comment
+
+```typescript
+{
+  id: "comment789",
+  type: "comment",
+  content: "I agree!",
+  parent_id: "comment123",       // ✅ Points to parent comment
+  thread_root_id: "memory456",   // ✅ Still points to root memory
+  moderation_flags: [],
+  spaces: ["the_void"],
+  author_id: "user999",
+  // ... other standard fields
+}
+```
+
+---
+
+## Files Modified
+
+- [`src/weaviate/schema.ts`](../../src/weaviate/schema.ts) - Add 3 fields to Memory schema
+- [`src/weaviate/space-schema.ts`](../../src/weaviate/space-schema.ts) - Add 3 fields to public collection
+
+---
+
+## Files Created
+
+None (schema updates only)
+
+---
+
+## Next Task
+
+Task 56: Update remember_search_space for Comments

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