@prmichaelsen/remember-mcp 3.12.0 → 3.14.0

package/src/tools/update-memory.ts

@@ -4,13 +4,10 @@
  */
 
 import type { Memory, MemoryUpdate } from '../types/memory.js';
-import { getMemoryCollection } from '../weaviate/schema.js';
-import { fetchMemoryWithAllProperties } from '../weaviate/client.js';
-import { logger } from '../utils/logger.js';
-import { handleToolError, withErrorHandling } from '../utils/error-handler.js';
-import { isValidContentType } from '../constants/content-types.js';
+import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_update_memory
@@ -133,196 +130,31 @@ export async function handleUpdateMemory(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    logger.info('Updating memory', { userId, memoryId: args.memory_id });
 
-    const collection = getMemoryCollection(userId);
-
-    // Get existing memory - fetch ALL properties for replace operation
-    // We need the full object to use replace() instead of update()
-    // (Weaviate bug: update() only persists if vectorized fields change)
-    // Use fetchMemoryWithAllProperties() to handle schema evolution gracefully
-    let existingMemory;
-    try {
-      existingMemory = await fetchMemoryWithAllProperties(collection, args.memory_id);
-    } catch (fetchError) {
-      const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);
-      logger.error('Failed to fetch memory for update:', {
-        error: fetchErrorMsg,
-        userId,
-        memoryId: args.memory_id,
-        collectionName: `Memory_${userId}`,
-      });
-      throw new Error(`Failed to fetch memory ${args.memory_id}: ${fetchErrorMsg}`);
-    }
-
-    if (!existingMemory || !existingMemory.properties) {
-      throw new Error(`Memory not found: ${args.memory_id}. It may have been deleted or never existed.`);
-    }
-
-    // Verify ownership
-    if (existingMemory.properties.user_id !== userId) {
-      throw new Error('Unauthorized: Cannot update another user\'s memory');
-    }
-
-    // Verify it's a memory (not a relationship)
-    if (existingMemory.properties.doc_type !== 'memory') {
-      throw new Error('Cannot update relationships using this tool. Use remember_update_relationship instead.');
-    }
-
-    // Check if memory is deleted
-    if (existingMemory.properties.deleted_at) {
-      const deletedAt = typeof existingMemory.properties.deleted_at === 'string'
-        ? existingMemory.properties.deleted_at
-        : new Date(existingMemory.properties.deleted_at as any).toISOString();
-      throw new Error(`Cannot update deleted memory: ${args.memory_id}. Memory was deleted on ${deletedAt}.`);
-    }
-
-    // Build update object with only provided fields
-    const updates: Record<string, any> = {};
-    const updatedFields: string[] = [];
-
-    // Update content fields
-    if (args.content !== undefined) {
-      updates.content = args.content;
-      updatedFields.push('content');
-    }
-
-    if (args.title !== undefined) {
-      updates.title = args.title;
-      updates.summary = args.title; // Keep summary in sync with title
-      updatedFields.push('title');
-    }
-
-    if (args.type !== undefined) {
-      if (!isValidContentType(args.type)) {
-        throw new Error(`Invalid content type: ${args.type}`);
-      }
-      updates.content_type = args.type;
-      updatedFields.push('content_type');
-    }
-
-    // Update scoring fields
-    if (args.weight !== undefined) {
-      if (args.weight < 0 || args.weight > 1) {
-        throw new Error('Weight must be between 0 and 1');
-      }
-      updates.weight = args.weight;
-      updates.base_weight = args.weight;
-      updates.computed_weight = args.weight; // Recalculate if needed
-      updatedFields.push('weight');
-    }
-
-    if (args.trust !== undefined) {
-      if (args.trust < 0 || args.trust > 1) {
-        throw new Error('Trust must be between 0 and 1');
-      }
-      updates.trust_score = args.trust;
-      updatedFields.push('trust_score');
-    }
-
-    // Update organization fields
-    if (args.tags !== undefined) {
-      updates.tags = args.tags;
-      updatedFields.push('tags');
-    }
-
-    if (args.references !== undefined) {
-      updates.references = args.references;
-      updatedFields.push('references');
-    }
-
-    // Update structured content
-    if (args.structured_content !== undefined) {
-      updates.structured_content = args.structured_content;
-      updatedFields.push('structured_content');
-    }
-
-    // NOTE: space_ids and group_ids (publication tracking arrays) are intentionally
-    // NOT exposed in UpdateMemoryArgs — they are managed exclusively by
-    // remember_publish and remember_retract. The spread below preserves them.
-
-    // Update comment/threading fields
-    if (args.parent_id !== undefined) {
-      updates.parent_id = args.parent_id;
-      updatedFields.push('parent_id');
-    }
-
-    if (args.thread_root_id !== undefined) {
-      updates.thread_root_id = args.thread_root_id;
-      updatedFields.push('thread_root_id');
-    }
-
-    if (args.moderation_flags !== undefined) {
-      updates.moderation_flags = args.moderation_flags;
-      updatedFields.push('moderation_flags');
-    }
-
-    // Check if any fields were provided
-    if (updatedFields.length === 0) {
-      throw new Error('No fields provided for update. At least one field must be specified.');
-    }
-
-    // Update metadata
-    const now = new Date().toISOString();
-    updates.updated_at = now;
-    updates.version = (existingMemory.properties.version as number) + 1;
-
-    // Merge updates with existing properties
-    // Use replace() instead of update() due to Weaviate bug where update() only
-    // persists if vectorized fields (content/observation) are changed
-    const mergedProperties = {
-      ...existingMemory.properties,
-      ...updates,
-    };
-    
-    logger.info('Calling Weaviate replace', {
-      userId,
-      memoryId: args.memory_id,
-      updateFields: Object.keys(updates),
-      updateValues: updates,
-      collectionName: `Memory_${userId}`,
-      totalProperties: Object.keys(mergedProperties).length,
-    });
-    
-    try {
-      await collection.data.replace({
-        id: args.memory_id,
-        properties: mergedProperties,
-      });
-      
-      logger.info('Weaviate replace completed (no error thrown)', {
-        userId,
-        memoryId: args.memory_id,
-        updatedFields: Object.keys(updates),
-      });
-    } catch (updateError) {
-      const updateErrorMsg = updateError instanceof Error ? updateError.message : String(updateError);
-      logger.error('Failed to perform Weaviate replace:', {
-        error: updateErrorMsg,
-        userId,
-        memoryId: args.memory_id,
-        updateFields: Object.keys(updates),
-        collectionName: `Memory_${userId}`,
-      });
-      throw new Error(`Failed to update memory in Weaviate: ${updateErrorMsg}`);
-    }
-
-    logger.info('Memory updated successfully', {
-      userId,
-      memoryId: args.memory_id,
-      version: updates.version,
-      updatedFields,
+    const { memory } = createCoreServices(userId);
+    const result = await memory.update({
+      memory_id: args.memory_id,
+      content: args.content,
+      title: args.title,
+      type: args.type,
+      weight: args.weight,
+      trust: args.trust,
+      tags: args.tags,
+      references: args.references,
+      parent_id: args.parent_id,
+      thread_root_id: args.thread_root_id,
+      moderation_flags: args.moderation_flags,
     });
 
-    const result: UpdateMemoryResult = {
-      memory_id: args.memory_id,
-      updated_at: now,
-      version: updates.version,
-      updated_fields: updatedFields,
-      message: `Memory updated successfully. Updated fields: ${updatedFields.join(', ')}`,
+    const response: UpdateMemoryResult = {
+      memory_id: result.memory_id,
+      updated_at: result.updated_at,
+      version: result.version,
+      updated_fields: result.updated_fields,
+      message: `Memory updated successfully. Updated fields: ${result.updated_fields.join(', ')}`,
     };
 
-    return JSON.stringify(result, null, 2);
+    return JSON.stringify(response, null, 2);
   } catch (error) {
     debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {

package/src/tools/update-relationship.ts

@@ -3,12 +3,10 @@
  * Update an existing relationship with partial updates
  */
 
-import type { RelationshipUpdate } from '../types/memory.js';
-import { getMemoryCollection } from '../weaviate/schema.js';
-import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_update_relationship
@@ -100,97 +98,25 @@ export async function handleUpdateRelationship(
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
 
-    logger.info('Updating relationship', { userId, relationshipId: args.relationship_id });
-
-    const collection = getMemoryCollection(userId);
-
-    // Get existing relationship to verify ownership and get current version
-    const existingRelationship = await collection.query.fetchObjectById(args.relationship_id, {
-      returnProperties: ['user_id', 'doc_type', 'version', 'relationship_type', 'strength', 'confidence'],
-    });
-
-    if (!existingRelationship) {
-      throw new Error(`Relationship not found: ${args.relationship_id}`);
-    }
-
-    // Verify ownership
-    if (existingRelationship.properties.user_id !== userId) {
-      throw new Error('Unauthorized: Cannot update another user\'s relationship');
-    }
-
-    // Verify it's a relationship (not a memory)
-    if (existingRelationship.properties.doc_type !== 'relationship') {
-      throw new Error('Cannot update memories using this tool. Use remember_update_memory instead.');
-    }
-
-    // Build update object with only provided fields
-    const updates: Record<string, any> = {};
-    const updatedFields: string[] = [];
-
-    // Update relationship fields
-    if (args.relationship_type !== undefined) {
-      updates.relationship_type = args.relationship_type;
-      updatedFields.push('relationship_type');
-    }
-
-    if (args.observation !== undefined) {
-      updates.observation = args.observation;
-      updatedFields.push('observation');
-    }
-
-    if (args.strength !== undefined) {
-      if (args.strength < 0 || args.strength > 1) {
-        throw new Error('Strength must be between 0 and 1');
-      }
-      updates.strength = args.strength;
-      updatedFields.push('strength');
-    }
-
-    if (args.confidence !== undefined) {
-      if (args.confidence < 0 || args.confidence > 1) {
-        throw new Error('Confidence must be between 0 and 1');
-      }
-      updates.confidence = args.confidence;
-      updatedFields.push('confidence');
-    }
-
-    if (args.tags !== undefined) {
-      updates.tags = args.tags;
-      updatedFields.push('tags');
-    }
-
-    // Check if any fields were provided
-    if (updatedFields.length === 0) {
-      throw new Error('No fields provided for update. At least one field must be specified.');
-    }
-
-    // Update metadata
-    const now = new Date().toISOString();
-    updates.updated_at = now;
-    updates.version = (existingRelationship.properties.version as number) + 1;
-
-    // Perform update in Weaviate
-    await collection.data.update({
-      id: args.relationship_id,
-      properties: updates,
-    });
-
-    logger.info('Relationship updated successfully', {
-      userId,
-      relationshipId: args.relationship_id,
-      version: updates.version,
-      updatedFields,
+    const { relationship } = createCoreServices(userId);
+    const result = await relationship.update({
+      relationship_id: args.relationship_id,
+      relationship_type: args.relationship_type,
+      observation: args.observation,
+      strength: args.strength,
+      confidence: args.confidence,
+      tags: args.tags,
     });
 
-    const result: UpdateRelationshipResult = {
-      relationship_id: args.relationship_id,
-      updated_at: now,
-      version: updates.version,
-      updated_fields: updatedFields,
-      message: `Relationship updated successfully. Updated fields: ${updatedFields.join(', ')}`,
+    const response: UpdateRelationshipResult = {
+      relationship_id: result.relationship_id,
+      updated_at: result.updated_at,
+      version: result.version,
+      updated_fields: result.updated_fields,
+      message: `Relationship updated successfully. Updated fields: ${result.updated_fields.join(', ')}`,
     };
 
-    return JSON.stringify(result, null, 2);
+    return JSON.stringify(response, null, 2);
   } catch (error) {
     debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {

package/src/v2-smoke.e2e.ts

@@ -17,13 +17,14 @@ dotenv.config({ path: process.env.DOTENV_CONFIG_PATH || '.env.e1.local', overrid
 
 import weaviate, { WeaviateClient, configure } from 'weaviate-client';
 import { config } from './config.js';
-import { generateCompositeId, parseCompositeId } from './collections/composite-ids.js';
 import {
+  generateCompositeId,
+  parseCompositeId,
   addToSpaceIds,
   addToGroupIds,
   isPublishedToSpace,
   getPublishedLocations,
-} from './collections/tracking-arrays.js';
+} from '@prmichaelsen/remember-core';
 
 // ---------------------------------------------------------------------------
 // Test constants

package/dist/collections/composite-ids.d.ts

@@ -1,106 +0,0 @@
-/**
- * Composite ID Utilities
- *
- * Provides utilities for working with composite IDs in Memory Collection Pattern v2.
- * Composite IDs preserve the source reference when memories are published to spaces or groups.
- *
- * Format: {userId}.{memoryId}
- * Example: "user123.my-recipe"
- */
-/**
- * Components of a composite ID
- */
-export interface CompositeIdComponents {
-    userId: string;
-    memoryId: string;
-}
-/**
- * Error thrown when composite ID is invalid
- */
-export declare class InvalidCompositeIdError extends Error {
-    constructor(message: string);
-}
-/**
- * Generate a composite ID from user ID and memory ID
- *
- * @param userId - User ID (must not contain dots)
- * @param memoryId - Memory ID (must not contain dots)
- * @returns Composite ID in format {userId}.{memoryId}
- * @throws {InvalidCompositeIdError} If userId or memoryId contains dots
- *
- * @example
- * generateCompositeId('user123', 'my-recipe')
- * // Returns: 'user123.my-recipe'
- */
-export declare function generateCompositeId(userId: string, memoryId: string): string;
-/**
- * Parse a composite ID into its components
- *
- * @param compositeId - Composite ID to parse
- * @returns Object with userId and memoryId
- * @throws {InvalidCompositeIdError} If composite ID format is invalid
- *
- * @example
- * parseCompositeId('user123.my-recipe')
- * // Returns: { userId: 'user123', memoryId: 'my-recipe' }
- */
-export declare function parseCompositeId(compositeId: string): CompositeIdComponents;
-/**
- * Check if a string is a composite ID
- *
- * @param id - String to check
- * @returns true if valid composite ID, false otherwise
- *
- * @example
- * isCompositeId('user123.my-recipe') // true
- * isCompositeId('simple-id') // false
- * isCompositeId('too.many.dots') // false
- */
-export declare function isCompositeId(id: string): boolean;
-/**
- * Validate a composite ID (returns true on valid, throws on invalid)
- *
- * @param id - Composite ID to validate
- * @returns true if valid
- * @throws {InvalidCompositeIdError} If composite ID is invalid
- *
- * @example
- * validateCompositeId('user123.my-recipe') // Returns true
- * validateCompositeId('invalid') // Throws InvalidCompositeIdError
- */
-export declare function validateCompositeId(id: string): true;
-/**
- * Extract user ID from a composite ID
- *
- * @param compositeId - Composite ID
- * @returns User ID component
- *
- * @example
- * getUserIdFromComposite('user123.my-recipe')
- * // Returns: 'user123'
- */
-export declare function getUserIdFromComposite(compositeId: string): string;
-/**
- * Extract memory ID from a composite ID
- *
- * @param compositeId - Composite ID
- * @returns Memory ID component
- *
- * @example
- * getMemoryIdFromComposite('user123.my-recipe')
- * // Returns: 'my-recipe'
- */
-export declare function getMemoryIdFromComposite(compositeId: string): string;
-/**
- * Check if an ID belongs to a specific user
- *
- * @param compositeId - Composite ID to check
- * @param userId - User ID to match
- * @returns true if composite ID belongs to user, false otherwise
- *
- * @example
- * belongsToUser('user123.my-recipe', 'user123') // true
- * belongsToUser('user123.my-recipe', 'user456') // false
- */
-export declare function belongsToUser(compositeId: string, userId: string): boolean;
-//# sourceMappingURL=composite-ids.d.ts.map

package/dist/collections/core-infrastructure.spec.d.ts

@@ -1,11 +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
- */
-export {};
-//# sourceMappingURL=core-infrastructure.spec.d.ts.map

package/dist/collections/dot-notation.d.ts

@@ -1,106 +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 declare 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 declare class InvalidCollectionNameError extends Error {
-    constructor(message: string);
-}
-/**
- * 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 declare function getCollectionName(type: CollectionType, id?: string): string;
-/**
- * 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 declare function parseCollectionName(name: string): CollectionMetadata;
-/**
- * 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 declare function validateCollectionName(name: string): boolean;
-/**
- * Check if a collection name is a user collection
- *
- * @param name - Collection name to check
- * @returns true if user collection, false otherwise
- */
-export declare function isUserCollection(name: string): boolean;
-/**
- * Check if a collection name is the spaces collection
- *
- * @param name - Collection name to check
- * @returns true if spaces collection, false otherwise
- */
-export declare function isSpacesCollection(name: string): boolean;
-/**
- * Check if a collection name is a group collection
- *
- * @param name - Collection name to check
- * @returns true if group collection, false otherwise
- */
-export declare function isGroupCollection(name: string): boolean;
-//# sourceMappingURL=dot-notation.d.ts.map