@prmichaelsen/remember-mcp 2.0.0 → 2.0.2

package/src/tools/create-memory.ts

@@ -6,6 +6,7 @@
 import type { Memory, ContentType, Location, MemoryContext } from '../types/memory.js';
 import { ensureMemoryCollection, getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 import { DEFAULT_CONTENT_TYPE, getContentTypeDescription, isValidContentType } from '../constants/content-types.js';
 
 /**
@@ -196,7 +197,12 @@ export async function handleCreateMemory(
 
     return JSON.stringify(response, null, 2);
   } catch (error) {
-    logger.error('Failed to create memory:', error);
-    throw new Error(`Failed to create memory: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_create_memory',
+      operation: 'create memory',
+      userId,
+      contentType: args.type,
+      hasContent: !!args.content,
+    });
   }
 }

package/src/tools/update-memory.ts

@@ -6,6 +6,7 @@
 import type { Memory, MemoryUpdate } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError, withErrorHandling } from '../utils/error-handler.js';
 import { isValidContentType } from '../constants/content-types.js';
 
 /**
@@ -113,12 +114,24 @@ export async function handleUpdateMemory(
     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'],
-    });
+    let existingMemory;
+    try {
+      existingMemory = await collection.query.fetchObjectById(args.memory_id, {
+        returnProperties: ['user_id', 'doc_type', 'version', 'type', 'weight', 'base_weight'],
+      });
+    } 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) {
-      throw new Error(`Memory not found: ${args.memory_id}`);
+      throw new Error(`Memory not found: ${args.memory_id}. It may have been deleted or never existed.`);
     }
 
     // Verify ownership
@@ -202,10 +215,22 @@ export async function handleUpdateMemory(
     updates.version = (existingMemory.properties.version as number) + 1;
 
     // Perform update in Weaviate
-    await collection.data.update({
-      id: args.memory_id,
-      properties: updates,
-    });
+    try {
+      await collection.data.update({
+        id: args.memory_id,
+        properties: updates,
+      });
+    } catch (updateError) {
+      const updateErrorMsg = updateError instanceof Error ? updateError.message : String(updateError);
+      logger.error('Failed to perform Weaviate update:', {
+        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,
@@ -224,7 +249,22 @@ export async function handleUpdateMemory(
 
     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)}`);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorStack = error instanceof Error ? error.stack : undefined;
+    
+    logger.error('Failed to update memory:', {
+      error: errorMessage,
+      stack: errorStack,
+      userId,
+      memoryId: args.memory_id,
+      providedFields: Object.keys(args).filter(k => k !== 'memory_id'),
+    });
+    
+    // Include detailed error information for debugging
+    throw new Error(
+      `Failed to update memory: ${errorMessage}` +
+      (errorStack ? `\n\nStack trace:\n${errorStack}` : '') +
+      `\n\nContext: userId=${userId}, memoryId=${args.memory_id}`
+    );
   }
 }

package/src/utils/error-handler.ts

@@ -0,0 +1,79 @@
+/**
+ * Centralized error handling utilities for MCP tools
+ * Provides consistent error logging and formatting across all tools
+ */
+
+import { logger } from './logger.js';
+
+/**
+ * Error context for detailed logging
+ */
+export interface ErrorContext {
+  toolName: string;
+  userId?: string;
+  operation?: string;
+  [key: string]: any;
+}
+
+/**
+ * Format error with detailed context for logging and throwing
+ * 
+ * @param error - The caught error
+ * @param context - Additional context about where/why the error occurred
+ * @returns Formatted error message with stack trace and context
+ */
+export function formatDetailedError(error: unknown, context: ErrorContext): string {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorStack = error instanceof Error ? error.stack : undefined;
+  
+  // Log detailed error information
+  logger.error(`${context.toolName} failed:`, {
+    error: errorMessage,
+    stack: errorStack,
+    ...context,
+  });
+  
+  // Build detailed error message
+  const contextStr = Object.entries(context)
+    .filter(([key]) => key !== 'toolName')
+    .map(([key, value]) => `${key}=${value}`)
+    .join(', ');
+  
+  return (
+    `Failed to ${context.operation || 'execute'}: ${errorMessage}` +
+    (errorStack ? `\n\nStack trace:\n${errorStack}` : '') +
+    (contextStr ? `\n\nContext: ${contextStr}` : '')
+  );
+}
+
+/**
+ * Handle tool execution error with detailed logging
+ * Logs the error and throws a formatted error with full context
+ * 
+ * @param error - The caught error
+ * @param context - Additional context about the operation
+ * @throws Error with detailed message including stack trace and context
+ */
+export function handleToolError(error: unknown, context: ErrorContext): never {
+  const detailedMessage = formatDetailedError(error, context);
+  throw new Error(detailedMessage);
+}
+
+/**
+ * Wrap an async operation with detailed error handling
+ * 
+ * @param operation - The async operation to execute
+ * @param context - Error context for logging
+ * @returns Result of the operation
+ * @throws Error with detailed context if operation fails
+ */
+export async function withErrorHandling<T>(
+  operation: () => Promise<T>,
+  context: ErrorContext
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error) {
+    handleToolError(error, context);
+  }
+}