@prmichaelsen/remember-mcp 0.1.0 → 0.2.1

package/src/tools/update-memory.ts

@@ -0,0 +1,230 @@
+/**
+ * remember_update_memory tool
+ * Update an existing memory with partial updates
+ */
+
+import type { Memory, MemoryUpdate } from '../types/memory.js';
+import { getMemoryCollection } from '../weaviate/schema.js';
+import { logger } from '../utils/logger.js';
+import { isValidContentType } from '../constants/content-types.js';
+
+/**
+ * Tool definition for remember_update_memory
+ */
+export const updateMemoryTool = {
+  name: 'remember_update_memory',
+  description: `Update an existing memory with partial updates.
+  
+  Supports updating any field except id, user_id, doc_type, created_at.
+  Version number is automatically incremented and updated_at is set.
+  Only provided fields are updated (partial updates supported).
+  
+  Examples:
+  - "Update that camping note to add more details"
+  - "Change the weight of my recipe memory"
+  - "Add tags to the meeting note from yesterday"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      memory_id: {
+        type: 'string',
+        description: 'ID of the memory to update',
+      },
+      content: {
+        type: 'string',
+        description: 'Updated memory content',
+      },
+      title: {
+        type: 'string',
+        description: 'Updated title',
+      },
+      type: {
+        type: 'string',
+        description: 'Updated content type',
+      },
+      weight: {
+        type: 'number',
+        description: 'Updated significance/priority (0-1)',
+        minimum: 0,
+        maximum: 1,
+      },
+      trust: {
+        type: 'number',
+        description: 'Updated access control level (0-1)',
+        minimum: 0,
+        maximum: 1,
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated tags (replaces existing tags)',
+      },
+      references: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated source URLs (replaces existing references)',
+      },
+      structured_content: {
+        type: 'object',
+        description: 'Updated structured content',
+      },
+    },
+    required: ['memory_id'],
+  },
+};
+
+/**
+ * Update memory arguments
+ */
+export interface UpdateMemoryArgs {
+  memory_id: string;
+  content?: string;
+  title?: string;
+  type?: string;
+  weight?: number;
+  trust?: number;
+  tags?: string[];
+  references?: string[];
+  structured_content?: Record<string, any>;
+}
+
+/**
+ * Update memory result
+ */
+export interface UpdateMemoryResult {
+  memory_id: string;
+  updated_at: string;
+  version: number;
+  updated_fields: string[];
+  message: string;
+}
+
+/**
+ * Handle remember_update_memory tool
+ */
+export async function handleUpdateMemory(
+  args: UpdateMemoryArgs,
+  userId: string
+): Promise<string> {
+  try {
+    logger.info('Updating memory', { userId, memoryId: args.memory_id });
+
+    const collection = getMemoryCollection(userId);
+
+    // Get existing memory to verify ownership and get current version
+    const existingMemory = await collection.query.fetchObjectById(args.memory_id, {
+      returnProperties: ['user_id', 'doc_type', 'version', 'type', 'weight', 'base_weight'],
+    });
+
+    if (!existingMemory) {
+      throw new Error(`Memory not found: ${args.memory_id}`);
+    }
+
+    // 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.');
+    }
+
+    // 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.type = args.type;
+      updatedFields.push('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 = args.trust;
+      updatedFields.push('trust');
+    }
+
+    // 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');
+    }
+
+    // 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;
+
+    // Perform update in Weaviate
+    await collection.data.update({
+      id: args.memory_id,
+      properties: updates,
+    });
+
+    logger.info('Memory updated successfully', {
+      userId,
+      memoryId: args.memory_id,
+      version: updates.version,
+      updatedFields,
+    });
+
+    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(', ')}`,
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error('Failed to update memory:', error);
+    throw new Error(`Failed to update memory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/update-relationship.ts

@@ -0,0 +1,189 @@
+/**
+ * remember_update_relationship tool
+ * 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';
+
+/**
+ * Tool definition for remember_update_relationship
+ */
+export const updateRelationshipTool = {
+  name: 'remember_update_relationship',
+  description: `Update an existing relationship with partial updates.
+  
+  Supports updating relationship_type, observation, strength, confidence, and tags.
+  Version number is automatically incremented and updated_at is set.
+  Only provided fields are updated (partial updates supported).
+  
+  Examples:
+  - "Update that relationship to increase the strength"
+  - "Change the observation text for the camping relationship"
+  - "Add tags to the inspiration relationship"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      relationship_id: {
+        type: 'string',
+        description: 'ID of the relationship to update',
+      },
+      relationship_type: {
+        type: 'string',
+        description: 'Updated relationship type',
+      },
+      observation: {
+        type: 'string',
+        description: 'Updated observation/description',
+      },
+      strength: {
+        type: 'number',
+        description: 'Updated strength (0-1)',
+        minimum: 0,
+        maximum: 1,
+      },
+      confidence: {
+        type: 'number',
+        description: 'Updated confidence (0-1)',
+        minimum: 0,
+        maximum: 1,
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Updated tags (replaces existing tags)',
+      },
+    },
+    required: ['relationship_id'],
+  },
+};
+
+/**
+ * Update relationship arguments
+ */
+export interface UpdateRelationshipArgs {
+  relationship_id: string;
+  relationship_type?: string;
+  observation?: string;
+  strength?: number;
+  confidence?: number;
+  tags?: string[];
+}
+
+/**
+ * Update relationship result
+ */
+export interface UpdateRelationshipResult {
+  relationship_id: string;
+  updated_at: string;
+  version: number;
+  updated_fields: string[];
+  message: string;
+}
+
+/**
+ * Handle remember_update_relationship tool
+ */
+export async function handleUpdateRelationship(
+  args: UpdateRelationshipArgs,
+  userId: string
+): Promise<string> {
+  try {
+    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 result: UpdateRelationshipResult = {
+      relationship_id: args.relationship_id,
+      updated_at: now,
+      version: updates.version,
+      updated_fields: updatedFields,
+      message: `Relationship updated successfully. Updated fields: ${updatedFields.join(', ')}`,
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error('Failed to update relationship:', error);
+    throw new Error(`Failed to update relationship: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}