@prmichaelsen/remember-mcp 2.3.4 → 2.5.1

package/agent/tasks/task-52-update-remember-query-space.md

@@ -0,0 +1,142 @@
+# Task 52: Update remember_query_space for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 51
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update the `remember_query_space` tool to accept a `spaces` array parameter, enabling RAG queries across multiple spaces simultaneously.
+
+---
+
+## Steps
+
+### 1. Update Tool Input Schema
+
+**File**: `src/tools/query-space.ts`
+
+**Change**:
+```typescript
+// Before
+space: {
+  type: 'string',
+  enum: SUPPORTED_SPACES,
+  default: 'the_void'
+}
+
+// After
+spaces: {
+  type: 'array',
+  items: {
+    type: 'string',
+    enum: SUPPORTED_SPACES
+  },
+  description: 'Spaces to query (e.g., ["the_void", "dogs"])',
+  minItems: 1,
+  default: ['the_void']
+}
+```
+
+### 2. Update handleQuerySpace Function
+
+**File**: `src/tools/query-space.ts`
+
+**Key Changes**:
+```typescript
+interface QuerySpaceArgs {
+  question: string;
+  spaces: string[];  // ✅ Changed from space: string
+  content_type?: string;
+  tags?: string[];
+  // ... other filters
+}
+
+export async function handleQuerySpace(
+  args: QuerySpaceArgs,
+  userId: string
+): Promise<string> {
+  // Validate all spaces
+  const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
+  if (invalidSpaces.length > 0) {
+    return JSON.stringify({
+      success: false,
+      error: 'Invalid space IDs'
+    }, null, 2);
+  }
+  
+  // Use unified public collection
+  const publicCollection = await ensurePublicCollection(weaviateClient);
+  
+  // Build filter for spaces array
+  const spacesFilter = publicCollection.filter
+    .byProperty('spaces')
+    .containsAny(args.spaces);  // ✅ Query multiple spaces!
+  
+  // ... rest of RAG query logic
+}
+```
+
+### 3. Update Response Format
+
+**File**: `src/tools/query-space.ts`
+
+Include which spaces were queried:
+```typescript
+return JSON.stringify({
+  success: true,
+  spaces_queried: args.spaces,  // ✅ Show what was queried
+  question: args.question,
+  results: formattedResults,
+  total: results.length
+}, null, 2);
+```
+
+### 4. Add Backward Compatibility (Optional)
+
+Support both `space` and `spaces` during migration:
+```typescript
+const spaces = args.spaces || (args.space ? [args.space] : ['the_void']);
+```
+
+### 5. Update Tests
+
+**File**: `tests/unit/query-space.test.ts` (create if doesn't exist)
+
+**Add tests**:
+- Query single space
+- Query multiple spaces
+- Results from all spaces returned
+- Invalid space validation
+- RAG query works across spaces
+
+---
+
+## Verification
+
+- [ ] Tool accepts `spaces` array parameter
+- [ ] Can query single space: `spaces: ["the_void"]`
+- [ ] Can query multiple spaces: `spaces: ["the_void", "dogs"]`
+- [ ] Uses `containsAny` filter for spaces array
+- [ ] RAG results include memories from all requested spaces
+- [ ] Invalid spaces rejected
+- [ ] Tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/tools/query-space.ts` - Update for multi-space query
+
+## Files Created
+
+- `tests/unit/query-space.test.ts` - Add multi-space tests (if doesn't exist)
+
+---
+
+**Next Task**: Task 53 - Add Multi-Space Unit Tests

package/agent/tasks/task-53-add-multispace-tests.md

@@ -0,0 +1,193 @@
+# Task 53: Add Multi-Space Unit Tests
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 3 hours
+**Dependencies**: Task 52
+**Status**: Not Started
+
+---
+
+## Objective
+
+Create comprehensive unit tests for the multi-space architecture, covering all scenarios including single-space, multi-space, edge cases, and error conditions.
+
+---
+
+## Steps
+
+### 1. Test Space Schema
+
+**File**: `src/weaviate/space-schema.spec.ts`
+
+**Add tests**:
+```typescript
+describe('Unified Public Collection', () => {
+  it('should create Memory_public collection', async () => {
+    // Test ensurePublicCollection()
+  });
+  
+  it('should have spaces array field in schema', () => {
+    // Verify schema includes spaces: text[]
+  });
+  
+  it('should support backward compatibility', () => {
+    // Test old getSpaceCollectionName() still works
+  });
+});
+```
+
+### 2. Test remember_publish
+
+**File**: `tests/unit/publish.test.ts`
+
+**Add tests**:
+```typescript
+describe('remember_publish multi-space', () => {
+  it('should accept single space', async () => {
+    const result = await handlePublish({
+      memory_id: 'mem123',
+      spaces: ['the_void']
+    }, 'user123');
+    // Verify token generated
+  });
+  
+  it('should accept multiple spaces', async () => {
+    const result = await handlePublish({
+      memory_id: 'mem123',
+      spaces: ['the_void', 'dogs', 'cats']
+    }, 'user123');
+    // Verify token generated with spaces array
+  });
+  
+  it('should reject invalid spaces', async () => {
+    const result = await handlePublish({
+      memory_id: 'mem123',
+      spaces: ['invalid_space']
+    }, 'user123');
+    // Verify error returned
+  });
+  
+  it('should reject empty spaces array', async () => {
+    const result = await handlePublish({
+      memory_id: 'mem123',
+      spaces: []
+    }, 'user123');
+    // Verify error returned
+  });
+});
+```
+
+### 3. Test remember_confirm
+
+**File**: `tests/unit/confirm.test.ts`
+
+**Add tests**:
+```typescript
+describe('remember_confirm multi-space', () => {
+  it('should publish to single space', async () => {
+    // Mock token with spaces: ['the_void']
+    // Verify memory inserted into Memory_public
+    // Verify spaces field is ['the_void']
+  });
+  
+  it('should publish to multiple spaces', async () => {
+    // Mock token with spaces: ['the_void', 'dogs']
+    // Verify memory inserted once
+    // Verify spaces field is ['the_void', 'dogs']
+  });
+  
+  it('should include all spaces in response', async () => {
+    // Verify response includes spaces array
+  });
+});
+```
+
+### 4. Test remember_search_space
+
+**File**: `tests/unit/search-space.test.ts`
+
+**Add tests**:
+```typescript
+describe('remember_search_space multi-space', () => {
+  it('should search single space', async () => {
+    // Search spaces: ['the_void']
+    // Verify containsAny filter used
+  });
+  
+  it('should search multiple spaces', async () => {
+    // Search spaces: ['the_void', 'dogs']
+    // Verify results from both spaces
+  });
+  
+  it('should find memories published to multiple spaces', async () => {
+    // Memory with spaces: ['the_void', 'dogs']
+    // Search spaces: ['the_void']
+    // Verify memory found
+  });
+  
+  it('should not find memories from other spaces', async () => {
+    // Memory with spaces: ['cats']
+    // Search spaces: ['dogs']
+    // Verify memory not found
+  });
+});
+```
+
+### 5. Test remember_query_space
+
+**File**: `tests/unit/query-space.test.ts`
+
+**Add tests**:
+```typescript
+describe('remember_query_space multi-space', () => {
+  it('should query single space', async () => {
+    // Query spaces: ['the_void']
+  });
+  
+  it('should query multiple spaces', async () => {
+    // Query spaces: ['the_void', 'dogs']
+    // Verify RAG results from both spaces
+  });
+});
+```
+
+### 6. Test Edge Cases
+
+**Add tests for**:
+- Duplicate spaces in array: `['the_void', 'the_void']`
+- Case sensitivity: `['The_Void']` vs `['the_void']`
+- Special characters in space names
+- Very long spaces array (100+ spaces)
+- Spaces array with null/undefined values
+
+---
+
+## Verification
+
+- [ ] All space schema tests passing
+- [ ] All publish tests passing (single + multi-space)
+- [ ] All confirm tests passing (single + multi-space)
+- [ ] All search tests passing (single + multi-space)
+- [ ] All query tests passing (single + multi-space)
+- [ ] Edge cases covered
+- [ ] Test coverage increased
+- [ ] All tests passing
+- [ ] TypeScript compiles without errors
+- [ ] Build successful
+
+---
+
+## Files Modified
+
+- `src/weaviate/space-schema.spec.ts` - Add unified collection tests
+
+## Files Created
+
+- `tests/unit/publish.test.ts` - Multi-space publish tests (if doesn't exist)
+- `tests/unit/confirm.test.ts` - Multi-space confirm tests (if doesn't exist)
+- `tests/unit/search-space.test.ts` - Multi-space search tests (if doesn't exist)
+- `tests/unit/query-space.test.ts` - Multi-space query tests (if doesn't exist)
+
+---
+
+**Next Task**: Task 54 - Update Documentation for Multi-Space

package/agent/tasks/task-54-update-documentation-multispace.md

@@ -0,0 +1,191 @@
+# Task 54: Update Documentation for Multi-Space
+
+**Milestone**: M11 - Unified Public Collection
+**Estimated Time**: 2 hours
+**Dependencies**: Task 53
+**Status**: Not Started
+
+---
+
+## Objective
+
+Update all documentation to reflect the new multi-space architecture, including README, CHANGELOG, and API examples.
+
+---
+
+## Steps
+
+### 1. Update README.md
+
+**File**: `README.md`
+
+**Update Shared Spaces section**:
+```markdown
+### Publishing Workflow
+
+1. **Request Publication**: Generate confirmation token
+\`\`\`typescript
+remember_publish({ 
+  memory_id: "abc123", 
+  spaces: ["the_void", "dogs"]  // ✅ Multiple spaces!
+})
+// Returns: { success: true, token: "xyz789" }
+\`\`\`
+
+2. **User Confirms**: Execute the publication
+\`\`\`typescript
+remember_confirm({ token: "xyz789" })
+// Returns: { 
+//   success: true, 
+//   space_memory_id: "new-id", 
+//   spaces: ["the_void", "dogs"] 
+// }
+\`\`\`
+
+3. **Discover**: Search multiple spaces
+\`\`\`typescript
+remember_search_space({ 
+  spaces: ["the_void", "dogs"],  // ✅ Search both at once!
+  query: "cute dog pictures" 
+})
+\`\`\`
+```
+
+### 2. Update CHANGELOG.md
+
+**File**: `CHANGELOG.md`
+
+**Add v2.4.0 entry**:
+```markdown
+## [2.4.0] - YYYY-MM-DD
+
+### ✨ Added
+
+- **Multi-Space Support**: Publish and search across multiple spaces simultaneously
+  - `spaces` array parameter in `remember_publish`
+  - `spaces` array parameter in `remember_search_space`
+  - `spaces` array parameter in `remember_query_space`
+  - Single memory can belong to multiple spaces
+  - No duplication - one memory, multiple spaces
+
+- **Unified Public Collection**: `Memory_public` replaces per-space collections
+  - All public memories in single collection
+  - Efficient storage (N× reduction)
+  - Simpler architecture
+
+### 🔧 Changed
+
+- `remember_publish`: `target` parameter → `spaces` array
+- `remember_search_space`: `space` parameter → `spaces` array
+- `remember_query_space`: `space` parameter → `spaces` array
+- SpaceMemory type: `space_id` field → `spaces` array
+- Collection strategy: Per-space → Unified public
+
+### 🔄 Migration
+
+**Backward Compatibility**: v2.4.0 supports both old and new formats
+- Old: `target: "the_void"` → New: `spaces: ["the_void"]`
+- Old: `space: "the_void"` → New: `spaces: ["the_void"]`
+
+**Breaking Changes in v3.0.0**:
+- Old format will be removed
+- Must use `spaces` array
+```
+
+### 3. Update Tool Documentation
+
+**Files**: `src/tools/publish.ts`, `src/tools/search-space.ts`, `src/tools/query-space.ts`
+
+Update JSDoc comments:
+```typescript
+/**
+ * remember_publish tool
+ * 
+ * Publish a memory to one or more shared spaces.
+ * 
+ * @example
+ * // Publish to single space
+ * remember_publish({ memory_id: "abc", spaces: ["the_void"] })
+ * 
+ * @example
+ * // Publish to multiple spaces
+ * remember_publish({ memory_id: "abc", spaces: ["the_void", "dogs", "cats"] })
+ */
+```
+
+### 4. Add Architecture Documentation
+
+**File**: `README.md` or create `docs/ARCHITECTURE.md`
+
+**Add section**:
+```markdown
+## Architecture: Unified Public Collection
+
+### Collection Strategy
+
+**Before v2.4.0** (Per-Space Collections):
+- `Memory_the_void` - Only "The Void" memories
+- `Memory_dogs` - Only "Dogs" memories
+- Problem: Can't search multiple spaces, memory duplication
+
+**After v2.4.0** (Unified Collection):
+- `Memory_public` - ALL public memories
+- `spaces: ["the_void", "dogs"]` - Memory in multiple spaces
+- Benefit: Multi-space search, no duplication, efficient storage
+
+### Multi-Space Search
+
+\`\`\`typescript
+// Search across multiple spaces in one query
+remember_search_space({
+  spaces: ["the_void", "dogs", "cats"],
+  query: "interesting ideas"
+})
+
+// Weaviate filter: spaces containsAny ["the_void", "dogs", "cats"]
+\`\`\`
+```
+
+### 5. Update Examples
+
+**File**: `README.md`
+
+Add multi-space examples to use cases:
+```markdown
+### Multi-Space Discovery
+
+- "Search the void and dogs for cute dog pictures"
+- "Find recipes in cooking and healthy-eating spaces"
+- "Discover tech content across programming and ai spaces"
+```
+
+---
+
+## Verification
+
+- [ ] README updated with multi-space examples
+- [ ] CHANGELOG.md has v2.4.0 entry
+- [ ] Tool JSDoc comments updated
+- [ ] Architecture section added
+- [ ] Migration guide included
+- [ ] Examples show multi-space usage
+- [ ] All documentation accurate
+- [ ] Links work correctly
+
+---
+
+## Files Modified
+
+- `README.md` - Add multi-space examples and architecture
+- `CHANGELOG.md` - Add v2.4.0 release notes
+- `src/tools/publish.ts` - Update JSDoc
+- `src/tools/search-space.ts` - Update JSDoc
+- `src/tools/query-space.ts` - Update JSDoc
+
+## Files Created
+
+- `docs/ARCHITECTURE.md` - Detailed architecture docs (optional)
+
+---
+
+**Next Task**: None - M11 Complete!