@prmichaelsen/remember-mcp 3.13.0 → 3.14.1

package/src/collections/core-infrastructure.spec.ts

@@ -1,353 +0,0 @@
-/**
- * Unit tests for Memory Collection Pattern v2 Core Infrastructure
- * 
- * Tests core functionality of:
- * - Dot notation collection utilities
- * - Composite ID utilities  
- * - Tracking array management
- * - Schema definitions
- */
-
-import {
-  CollectionType,
-  getCollectionName,
-  parseCollectionName,
-  validateCollectionName,
-  isUserCollection,
-  isSpacesCollection,
-  isGroupCollection,
-} from './dot-notation.js';
-
-import {
-  generateCompositeId,
-  parseCompositeId,
-  isCompositeId,
-  validateCompositeId,
-} from './composite-ids.js';
-
-import {
-  addToSpaceIds,
-  removeFromSpaceIds,
-  addToGroupIds,
-  removeFromGroupIds,
-  isPublishedToSpace,
-  isPublishedToGroup,
-  getPublishedLocations,
-  isPublished,
-  getPublishedCount,
-  initializeTracking,
-  addMultipleSpaceIds,
-  addMultipleGroupIds,
-  type MemoryWithTracking,
-} from './tracking-arrays.js';
-
-import {
-  createUserCollectionSchema,
-  createSpaceCollectionSchema,
-  createGroupCollectionSchema,
-  getUserCollectionProperties,
-  getPublishedCollectionProperties,
-  validateV2CollectionName,
-  getCollectionType,
-  extractIdFromCollectionName,
-} from '../schema/v2-collections.js';
-
-// ============================================================================
-// Dot Notation Collection Utilities Tests
-// ============================================================================
-
-describe('Dot Notation Collection Utilities', () => {
-  describe('getCollectionName', () => {
-    it('should generate user collection name', () => {
-      expect(getCollectionName(CollectionType.USERS, 'user123')).toBe('Memory_users_user123');
-    });
-
-    it('should generate spaces collection name', () => {
-      expect(getCollectionName(CollectionType.SPACES)).toBe('Memory_spaces_public');
-    });
-
-    it('should generate group collection name', () => {
-      expect(getCollectionName(CollectionType.GROUPS, 'group456')).toBe('Memory_groups_group456');
-    });
-
-    it('should throw error for user collection without ID', () => {
-      expect(() => getCollectionName(CollectionType.USERS)).toThrow('User ID is required');
-    });
-
-    it('should throw error for ID with invalid characters', () => {
-      expect(() => getCollectionName(CollectionType.USERS, 'user.123')).toThrow();
-    });
-  });
-
-  describe('parseCollectionName', () => {
-    it('should parse user collection name', () => {
-      const result = parseCollectionName('Memory_users_user123');
-      expect(result.type).toBe(CollectionType.USERS);
-      expect(result.id).toBe('user123');
-    });
-
-    it('should parse spaces collection name', () => {
-      const result = parseCollectionName('Memory_spaces_public');
-      expect(result.type).toBe(CollectionType.SPACES);
-      expect(result.id).toBeUndefined();
-    });
-
-    it('should parse group collection name', () => {
-      const result = parseCollectionName('Memory_groups_group456');
-      expect(result.type).toBe(CollectionType.GROUPS);
-      expect(result.id).toBe('group456');
-    });
-  });
-
-  describe('Collection type checkers', () => {
-    it('should identify user collections', () => {
-      expect(isUserCollection('Memory_users_user123')).toBe(true);
-      expect(isUserCollection('Memory_spaces_public')).toBe(false);
-    });
-
-    it('should identify spaces collection', () => {
-      expect(isSpacesCollection('Memory_spaces_public')).toBe(true);
-      expect(isSpacesCollection('Memory_users_user123')).toBe(false);
-    });
-
-    it('should identify group collections', () => {
-      expect(isGroupCollection('Memory_groups_group456')).toBe(true);
-      expect(isGroupCollection('Memory_users_user123')).toBe(false);
-    });
-  });
-});
-
-// ============================================================================
-// Composite ID Utilities Tests
-// ============================================================================
-
-describe('Composite ID Utilities', () => {
-  describe('generateCompositeId', () => {
-    it('should generate composite ID', () => {
-      expect(generateCompositeId('user123', 'my-recipe')).toBe('user123.my-recipe');
-    });
-
-    it('should throw error for userId with dots', () => {
-      expect(() => generateCompositeId('user.123', 'recipe')).toThrow('cannot contain dots');
-    });
-
-    it('should throw error for empty userId', () => {
-      expect(() => generateCompositeId('', 'recipe')).toThrow('cannot be empty');
-    });
-  });
-
-  describe('parseCompositeId', () => {
-    it('should parse composite ID', () => {
-      const result = parseCompositeId('user123.my-recipe');
-      expect(result.userId).toBe('user123');
-      expect(result.memoryId).toBe('my-recipe');
-    });
-
-    it('should throw error for invalid format', () => {
-      expect(() => parseCompositeId('invalid')).toThrow('must be exactly 2 parts');
-    });
-  });
-
-  describe('isCompositeId', () => {
-    it('should identify valid composite IDs', () => {
-      expect(isCompositeId('user123.my-recipe')).toBe(true);
-      expect(isCompositeId('simple-id')).toBe(false);
-    });
-  });
-
-  describe('validateCompositeId', () => {
-    it('should validate correct composite IDs', () => {
-      expect(validateCompositeId('user123.my-recipe')).toBe(true);
-    });
-
-    it('should throw error for invalid IDs', () => {
-      expect(() => validateCompositeId('invalid')).toThrow();
-    });
-  });
-});
-
-// ============================================================================
-// Tracking Array Management Tests
-// ============================================================================
-
-describe('Tracking Array Management', () => {
-  describe('addToSpaceIds', () => {
-    it('should add space ID to existing arrays', () => {
-      const memory: MemoryWithTracking = { space_ids: [], group_ids: [] };
-      const result = addToSpaceIds(memory, 'cooking');
-      expect(result.space_ids).toEqual(['cooking']);
-    });
-
-    it('should not add duplicate space IDs', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking'], group_ids: [] };
-      const result = addToSpaceIds(memory, 'cooking');
-      expect(result.space_ids).toEqual(['cooking']);
-    });
-
-    it('should be immutable', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking'], group_ids: [] };
-      const result = addToSpaceIds(memory, 'recipes');
-      expect(memory.space_ids).toEqual(['cooking']); // Original unchanged
-      expect(result.space_ids).toEqual(['cooking', 'recipes']);
-    });
-  });
-
-  describe('removeFromSpaceIds', () => {
-    it('should remove space ID', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking', 'recipes'], group_ids: [] };
-      const result = removeFromSpaceIds(memory, 'cooking');
-      expect(result.space_ids).toEqual(['recipes']);
-    });
-  });
-
-  describe('addToGroupIds', () => {
-    it('should add group ID', () => {
-      const memory: MemoryWithTracking = { space_ids: [], group_ids: ['family'] };
-      const result = addToGroupIds(memory, 'friends');
-      expect(result.group_ids).toEqual(['family', 'friends']);
-    });
-  });
-
-  describe('removeFromGroupIds', () => {
-    it('should remove group ID', () => {
-      const memory: MemoryWithTracking = { space_ids: [], group_ids: ['family', 'friends'] };
-      const result = removeFromGroupIds(memory, 'family');
-      expect(result.group_ids).toEqual(['friends']);
-    });
-  });
-
-  describe('Publication checks', () => {
-    it('should check if published to space', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking'], group_ids: [] };
-      expect(isPublishedToSpace(memory, 'cooking')).toBe(true);
-      expect(isPublishedToSpace(memory, 'travel')).toBe(false);
-    });
-
-    it('should check if published to group', () => {
-      const memory: MemoryWithTracking = { space_ids: [], group_ids: ['family'] };
-      expect(isPublishedToGroup(memory, 'family')).toBe(true);
-      expect(isPublishedToGroup(memory, 'coworkers')).toBe(false);
-    });
-
-    it('should get publication locations', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking'], group_ids: ['family'] };
-      const result = getPublishedLocations(memory);
-      expect(result).toEqual({ spaces: ['cooking'], groups: ['family'] });
-    });
-
-    it('should check if published anywhere', () => {
-      const memory1: MemoryWithTracking = { space_ids: ['cooking'], group_ids: [] };
-      expect(isPublished(memory1)).toBe(true);
-      
-      const memory2: MemoryWithTracking = { space_ids: [], group_ids: [] };
-      expect(isPublished(memory2)).toBe(false);
-    });
-
-    it('should count publications', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking', 'recipes'], group_ids: ['family'] };
-      expect(getPublishedCount(memory)).toBe(3);
-    });
-  });
-
-  describe('Batch operations', () => {
-    it('should add multiple space IDs', () => {
-      const memory: MemoryWithTracking = { space_ids: ['cooking'], group_ids: [] };
-      const result = addMultipleSpaceIds(memory, ['recipes', 'baking']);
-      expect(result.space_ids).toEqual(['cooking', 'recipes', 'baking']);
-    });
-
-    it('should add multiple group IDs', () => {
-      const memory: MemoryWithTracking = { space_ids: [], group_ids: ['family'] };
-      const result = addMultipleGroupIds(memory, ['friends', 'coworkers']);
-      expect(result.group_ids).toEqual(['family', 'friends', 'coworkers']);
-    });
-  });
-
-  describe('Utility functions', () => {
-    it('should initialize tracking arrays', () => {
-      const memory = { content: 'My recipe' };
-      const result = initializeTracking(memory);
-      expect(result.space_ids).toEqual([]);
-      expect(result.group_ids).toEqual([]);
-    });
-  });
-});
-
-// ============================================================================
-// Schema Definitions Tests
-// ============================================================================
-
-describe('Schema Definitions', () => {
-  describe('Schema creation', () => {
-    it('should create user collection schema', () => {
-      const schema = createUserCollectionSchema('user123');
-      expect(schema.name).toBe('Memory_users_user123');
-      expect(schema.description).toContain('user123');
-      expect(schema.properties).toBeDefined();
-      expect(schema.vectorizers).toBeDefined();
-    });
-
-    it('should create space collection schema', () => {
-      const schema = createSpaceCollectionSchema();
-      expect(schema.name).toBe('Memory_spaces_public');
-      expect(schema.properties).toBeDefined();
-    });
-
-    it('should create group collection schema', () => {
-      const schema = createGroupCollectionSchema('group456');
-      expect(schema.name).toBe('Memory_groups_group456');
-      expect(schema.properties).toBeDefined();
-    });
-  });
-
-  describe('Property lists', () => {
-    it('should get user collection properties', () => {
-      const props = getUserCollectionProperties();
-      expect(props).not.toContain('id'); // 'id' is reserved by Weaviate
-      expect(props).toContain('content');
-      expect(props).toContain('space_ids');
-      expect(props).toContain('group_ids');
-    });
-
-    it('should get published collection properties', () => {
-      const props = getPublishedCollectionProperties();
-      expect(props).not.toContain('id'); // 'id' is reserved by Weaviate
-      expect(props).toContain('published_at');
-      expect(props).toContain('author_id');
-    });
-  });
-
-  describe('Collection name validation', () => {
-    it('should validate v2 collection names', () => {
-      expect(validateV2CollectionName('Memory_users_user123')).toBe(true);
-      expect(validateV2CollectionName('Memory_spaces_public')).toBe(true);
-      expect(validateV2CollectionName('Memory_groups_group456')).toBe(true);
-    });
-
-    it('should reject invalid collection names', () => {
-      expect(() => validateV2CollectionName('InvalidName')).toThrow('Invalid v2 collection name');
-    });
-  });
-
-  describe('Collection type detection', () => {
-    it('should detect collection types', () => {
-      expect(getCollectionType('Memory_users_user123')).toBe('users');
-      expect(getCollectionType('Memory_spaces_public')).toBe('spaces');
-      expect(getCollectionType('Memory_groups_group456')).toBe('groups');
-    });
-  });
-
-  describe('ID extraction', () => {
-    it('should extract user ID', () => {
-      expect(extractIdFromCollectionName('Memory_users_user123')).toBe('user123');
-    });
-
-    it('should extract group ID', () => {
-      expect(extractIdFromCollectionName('Memory_groups_group456')).toBe('group456');
-    });
-
-    it('should return null for spaces collection', () => {
-      expect(extractIdFromCollectionName('Memory_spaces_public')).toBeNull();
-    });
-  });
-});

package/src/collections/dot-notation.ts

@@ -1,212 +0,0 @@
-/**
- * Dot Notation Collection Utilities
- * 
- * Provides utilities for working with Memory Collection Pattern v2's
- * dot notation collection naming scheme.
- * 
- * Collection Types:
- * - USERS: Memory_users_{userId} - Private user memories
- * - SPACES: Memory_spaces_public - All public space memories
- * - GROUPS: Memory_groups_{groupId} - Group memories
- */
-
-/**
- * Collection type enum for Memory Collection Pattern v2
- */
-export enum CollectionType {
-  USERS = 'USERS',
-  SPACES = 'SPACES',
-  GROUPS = 'GROUPS',
-}
-
-/**
- * Metadata about a parsed collection
- */
-export interface CollectionMetadata {
-  type: CollectionType
-  id?: string
-  name: string
-}
-
-/**
- * Error thrown when collection name is invalid
- */
-export class InvalidCollectionNameError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidCollectionNameError'
-  }
-}
-
-/**
- * Get the Weaviate collection name for a given type and optional ID
- * 
- * @param type - Collection type (USERS, SPACES, or GROUPS)
- * @param id - Optional ID (required for USERS and GROUPS, not used for SPACES)
- * @returns Weaviate collection name
- * 
- * @example
- * getCollectionName(CollectionType.USERS, 'user123')
- * // Returns: 'Memory_users_user123'
- * 
- * @example
- * getCollectionName(CollectionType.SPACES)
- * // Returns: 'Memory_spaces_public'
- * 
- * @example
- * getCollectionName(CollectionType.GROUPS, 'group456')
- * // Returns: 'Memory_groups_group456'
- */
-export function getCollectionName(type: CollectionType, id?: string): string {
-  switch (type) {
-    case CollectionType.USERS:
-      if (!id) {
-        throw new InvalidCollectionNameError('User ID is required for USERS collection type')
-      }
-      if (id.includes('.')) {
-        throw new InvalidCollectionNameError(`User ID cannot contain dots: ${id}`)
-      }
-      return `Memory_users_${id}`
-    
-    case CollectionType.SPACES:
-      // SPACES collection is always public, ID is not used
-      return 'Memory_spaces_public'
-    
-    case CollectionType.GROUPS:
-      if (!id) {
-        throw new InvalidCollectionNameError('Group ID is required for GROUPS collection type')
-      }
-      if (id.includes('.')) {
-        throw new InvalidCollectionNameError(`Group ID cannot contain dots: ${id}`)
-      }
-      return `Memory_groups_${id}`
-    
-    default:
-      throw new InvalidCollectionNameError(`Unknown collection type: ${type}`)
-  }
-}
-
-/**
- * Parse a collection name into its components
- * 
- * @param name - Weaviate collection name
- * @returns Collection metadata with type, optional ID, and name
- * 
- * @example
- * parseCollectionName('Memory_users_user123')
- * // Returns: { type: CollectionType.USERS, id: 'user123', name: 'Memory_users_user123' }
- * 
- * @example
- * parseCollectionName('Memory_spaces_public')
- * // Returns: { type: CollectionType.SPACES, id: undefined, name: 'Memory_spaces_public' }
- * 
- * @example
- * parseCollectionName('Memory_groups_group456')
- * // Returns: { type: CollectionType.GROUPS, id: 'group456', name: 'Memory_groups_group456' }
- */
-export function parseCollectionName(name: string): CollectionMetadata {
-  // Match pattern: Memory_{type}_{id} or Memory_{type}_public
-  const match = name.match(/^Memory_(users|spaces|groups)_(.+)$/)
-  
-  if (!match) {
-    throw new InvalidCollectionNameError(
-      `Invalid collection name format: ${name}. Expected format: Memory_{type}_{id}`
-    )
-  }
-  
-  const [, typeStr, idOrPublic] = match
-  
-  switch (typeStr) {
-    case 'users':
-      return {
-        type: CollectionType.USERS,
-        id: idOrPublic,
-        name,
-      }
-    
-    case 'spaces':
-      if (idOrPublic !== 'public') {
-        throw new InvalidCollectionNameError(
-          `Invalid SPACES collection name: ${name}. Expected: Memory_spaces_public`
-        )
-      }
-      return {
-        type: CollectionType.SPACES,
-        id: undefined,
-        name,
-      }
-    
-    case 'groups':
-      return {
-        type: CollectionType.GROUPS,
-        id: idOrPublic,
-        name,
-      }
-    
-    default:
-      throw new InvalidCollectionNameError(`Unknown collection type: ${typeStr}`)
-  }
-}
-
-/**
- * Validate a collection name
- * 
- * @param name - Collection name to validate
- * @returns true if valid, false otherwise
- * 
- * @example
- * validateCollectionName('Memory_users_user123') // true
- * validateCollectionName('Memory_spaces_public') // true
- * validateCollectionName('Invalid_name') // false
- */
-export function validateCollectionName(name: string): boolean {
-  try {
-    parseCollectionName(name)
-    return true
-  } catch (error) {
-    if (error instanceof InvalidCollectionNameError) {
-      return false
-    }
-    throw error
-  }
-}
-
-/**
- * Check if a collection name is a user collection
- * 
- * @param name - Collection name to check
- * @returns true if user collection, false otherwise
- */
-export function isUserCollection(name: string): boolean {
-  try {
-    const metadata = parseCollectionName(name)
-    return metadata.type === CollectionType.USERS
-  } catch {
-    return false
-  }
-}
-
-/**
- * Check if a collection name is the spaces collection
- * 
- * @param name - Collection name to check
- * @returns true if spaces collection, false otherwise
- */
-export function isSpacesCollection(name: string): boolean {
-  return name === 'Memory_spaces_public'
-}
-
-/**
- * Check if a collection name is a group collection
- * 
- * @param name - Collection name to check
- * @returns true if group collection, false otherwise
- */
-export function isGroupCollection(name: string): boolean {
-  try {
-    const metadata = parseCollectionName(name)
-    return metadata.type === CollectionType.GROUPS
-  } catch {
-    return false
-  }
-}