@prmichaelsen/remember-mcp 2.7.10 → 2.8.0

package/src/tools/confirm.ts

@@ -11,6 +11,7 @@ import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllPropertie
 import { ensurePublicCollection } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { logger } from '../utils/logger.js';
+import { createDebugLogger } from '../utils/debug.js';
 
 /**
  * Tool definition for remember_confirm
@@ -63,7 +64,16 @@ export async function handleConfirm(
   args: ConfirmArgs,
   userId: string
 ): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_confirm',
+    userId,
+    operation: 'confirm_action',
+  });
+
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { token: args.token });
+    
     logger.info('Starting confirmation', {
       tool: 'remember_confirm',
       userId,
@@ -71,7 +81,10 @@ export async function handleConfirm(
     });
     
     // Validate and confirm token
-    const request = await confirmationTokenService.confirmRequest(userId, args.token);
+    debug.debug('Validating confirmation token');
+    const request = await debug.time('Confirm token', async () => {
+      return await confirmationTokenService.confirmRequest(userId, args.token);
+    });
     
     logger.debug('Token validation result', {
       tool: 'remember_confirm',
@@ -114,6 +127,10 @@ export async function handleConfirm(
 
     throw new Error(`Unknown action type: ${request.action}`);
   } catch (error) {
+    debug.error('Tool failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
     handleToolError(error, {
       toolName: 'remember_confirm',
       userId,
@@ -130,7 +147,18 @@ async function executePublishMemory(
   request: ConfirmationRequest & { request_id: string },
   userId: string
 ): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_confirm',
+    userId,
+    operation: 'execute_publish',
+  });
+
   try {
+    debug.debug('Executing publish memory action', {
+      memoryId: request.payload.memory_id,
+      spaces: request.payload.spaces,
+    });
+    
     logger.info('Executing publish memory action', {
       function: 'executePublishMemory',
       userId,
@@ -151,10 +179,12 @@ async function executePublishMemory(
       memoryId: request.payload.memory_id,
     });
 
-    const originalMemory = await fetchMemoryWithAllProperties(
-      userCollection,
-      request.payload.memory_id
-    );
+    const originalMemory = await debug.time('Fetch original memory', async () => {
+      return await fetchMemoryWithAllProperties(
+        userCollection,
+        request.payload.memory_id
+      );
+    });
     
     logger.info('Original memory fetch result', {
       function: 'executePublishMemory',
@@ -188,6 +218,28 @@ async function executePublishMemory(
       );
     }
 
+    // Check if memory has already been published
+    if (originalMemory.properties.space_memory_id) {
+      const requestedSpaces = request.payload.spaces?.join(', ') || 'unknown';
+      logger.warn('Memory already published', {
+        function: 'executePublishMemory',
+        memoryId: request.payload.memory_id,
+        existingSpaceMemoryId: originalMemory.properties.space_memory_id,
+        requestedSpaces: request.payload.spaces,
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Already published',
+          message: `This memory has already been published to this space. Space memory ID: ${originalMemory.properties.space_memory_id}`,
+          space_memory_id: originalMemory.properties.space_memory_id,
+          requested_spaces: request.payload.spaces,
+        },
+        null,
+        2
+      );
+    }
+
     // Verify ownership again
     if (originalMemory.properties.user_id !== userId) {
       logger.warn('Permission denied - wrong owner', {
@@ -264,8 +316,10 @@ async function executePublishMemory(
     
     // Insert directly into unified public collection
     // CRITICAL: Weaviate insert API expects {properties: {...}}, not the properties directly!
-    const result = await publicCollection.data.insert({
-      properties: publishedMemory,
+    const result = await debug.time('Insert into Memory_public', async () => {
+      return await publicCollection.data.insert({
+        properties: publishedMemory,
+      });
     });
     
     logger.info('Memory published successfully', {
@@ -273,6 +327,11 @@ async function executePublishMemory(
       spaceMemoryId: result,
       spaces: request.payload.spaces,
     });
+    
+    debug.info('Memory published successfully', {
+      spaceMemoryId: result,
+      spaces: request.payload.spaces,
+    });
 
     // Update original memory with space_memory_id for bidirectional linking
     try {
@@ -309,6 +368,10 @@ async function executePublishMemory(
       2
     );
   } catch (error) {
+    debug.error('Execute publish failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
     handleToolError(error, {
       toolName: 'remember_confirm',
       userId,

package/src/tools/publish.ts

@@ -12,6 +12,7 @@ import { isValidSpaceId } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
 import { logger } from '../utils/logger.js';
+import { createDebugLogger } from '../utils/debug.js';
 
 /**
  * Tool definition for remember_publish
@@ -62,7 +63,16 @@ export async function handlePublish(
   args: PublishArgs,
   userId: string
 ): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_publish',
+    userId,
+    operation: 'publish_request',
+  });
+
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+    
     logger.info('Starting publish request', {
       tool: 'remember_publish',
       userId,
@@ -73,8 +83,10 @@ export async function handlePublish(
     });
     
     // Validate all space IDs
+    debug.debug('Validating space IDs', { spaces: args.spaces });
     const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
+      debug.warn('Invalid space IDs detected', { invalidSpaces });
       logger.warn('Invalid space IDs provided', {
         tool: 'remember_publish',
         invalidSpaces,
@@ -124,7 +136,9 @@ export async function handlePublish(
     
     const userCollection = weaviateClient.collections.get(collectionName);
 
-    const memory = await fetchMemoryWithAllProperties(userCollection, args.memory_id);
+    const memory = await debug.time('Fetch memory from user collection', async () => {
+      return await fetchMemoryWithAllProperties(userCollection, args.memory_id);
+    });
     
     logger.debug('Memory fetch result', {
       tool: 'remember_publish',
@@ -232,6 +246,10 @@ export async function handlePublish(
       2
     );
   } catch (error) {
+    debug.error('Tool failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
     return handleToolError(error, {
       toolName: 'remember_publish',
       userId,

package/src/tools/query-space.ts

@@ -11,6 +11,7 @@ import { getWeaviateClient } from '../weaviate/client.js';
 import { ensurePublicCollection, isValidSpaceId } from '../weaviate/space-schema.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
 import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
 
 /**
  * Tool definition for remember_query_space
@@ -106,8 +107,18 @@ export async function handleQuerySpace(
   args: QuerySpaceArgs,
   userId: string  // May be used for private spaces in future
 ): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_query_space',
+    userId,
+    operation: 'query_spaces',
+  });
+
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+    
     // Validate all space IDs
+    debug.debug('Validating space IDs', { spaces: args.spaces });
     const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
       return JSON.stringify(
@@ -181,10 +192,23 @@ export async function handleQuerySpace(
 
     const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
 
-    // Execute semantic search using nearText
-    const searchResults = await publicCollection.query.nearText(args.question, {
+    debug.debug('Executing semantic query', {
+      question: args.question,
+      filterCount: filterList.length,
       limit: args.limit || 10,
-      ...(whereFilter && { where: whereFilter }),
+    });
+
+    // Execute semantic search using nearText
+    const searchResults = await debug.time('Semantic query', async () => {
+      return await publicCollection.query.nearText(args.question, {
+        limit: args.limit || 10,
+        ...(whereFilter && { where: whereFilter }),
+      });
+    });
+    
+    debug.debug('Query completed', {
+      resultCount: searchResults.objects.length,
+      format: args.format || 'detailed',
     });
 
     // Format results based on requested format
@@ -222,9 +246,18 @@ export async function handleQuerySpace(
         total: memories.length,
       };
 
+      debug.info('Tool completed successfully', {
+        resultCount: memories.length,
+        format: 'detailed',
+      });
+      
       return JSON.stringify(result, null, 2);
     }
   } catch (error) {
+    debug.error('Tool failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
     return handleToolError(error, {
       toolName: 'remember_query_space',
       operation: 'query spaces',

package/src/tools/search-space.ts

@@ -12,6 +12,7 @@ import { ensurePublicCollection, isValidSpaceId } from '../weaviate/space-schema
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
 import { handleToolError } from '../utils/error-handler.js';
 import type { SearchFilters } from '../types/memory.js';
+import { createDebugLogger } from '../utils/debug.js';
 
 /**
  * Tool definition for remember_search_space
@@ -113,8 +114,18 @@ export async function handleSearchSpace(
   args: SearchSpaceArgs,
   userId: string  // May be used for private spaces in future
 ): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_search_space',
+    userId,
+    operation: 'search_spaces',
+  });
+
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+    
     // Validate all space IDs
+    debug.debug('Validating space IDs', { spaces: args.spaces });
     const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
       return JSON.stringify(
@@ -197,11 +208,24 @@ export async function handleSearchSpace(
 
     const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
 
-    // Execute hybrid search
-    const searchResults = await publicCollection.query.hybrid(args.query, {
+    debug.debug('Executing hybrid search', {
+      query: args.query,
+      filterCount: filterList.length,
       limit: args.limit || 10,
       offset: args.offset || 0,
-      ...(whereFilter && { where: whereFilter }),
+    });
+
+    // Execute hybrid search
+    const searchResults = await debug.time('Hybrid search query', async () => {
+      return await publicCollection.query.hybrid(args.query, {
+        limit: args.limit || 10,
+        offset: args.offset || 0,
+        ...(whereFilter && { where: whereFilter }),
+      });
+    });
+    
+    debug.debug('Search completed', {
+      resultCount: searchResults.objects.length,
     });
 
     // Format results
@@ -220,8 +244,17 @@ export async function handleSearchSpace(
       limit: args.limit || 10,
     };
 
+    debug.info('Tool completed successfully', {
+      resultCount: memories.length,
+      spaces: args.spaces,
+    });
+
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error('Tool failed', {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
     return handleToolError(error, {
       toolName: 'remember_search_space',
       operation: 'search spaces',

package/src/utils/debug.spec.ts

@@ -0,0 +1,257 @@
+/**
+ * Unit tests for debug utility
+ */
+
+import { createDebugLogger, DebugLogger } from './debug';
+import { DebugLevel } from '../config';
+import { logger } from './logger';
+
+// Mock logger
+jest.mock('./logger', () => ({
+  logger: {
+    debug: jest.fn(),
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+// Mock config
+jest.mock('../config', () => {
+  let mockLevel = 0; // NONE by default
+  
+  return {
+    DebugLevel: {
+      NONE: 0,
+      ERROR: 1,
+      WARN: 2,
+      INFO: 3,
+      DEBUG: 4,
+      TRACE: 5,
+    },
+    debugConfig: {
+      get level() {
+        return mockLevel;
+      },
+      set level(value: number) {
+        mockLevel = value;
+      },
+      enabled: (level: number) => mockLevel >= level,
+    },
+    // Re-export setMockDebugLevel for tests
+    __setMockDebugLevel: (level: number) => {
+      mockLevel = level;
+    },
+  };
+});
+
+const { __setMockDebugLevel } = require('../config');
+
+describe('DebugLogger', () => {
+  let debug: DebugLogger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    __setMockDebugLevel(DebugLevel.NONE);
+    debug = createDebugLogger({
+      tool: 'test_tool',
+      userId: 'user123',
+      operation: 'test_operation',
+    });
+  });
+
+  describe('Debug Level Filtering', () => {
+    it('should not log anything when level is NONE', () => {
+      __setMockDebugLevel(DebugLevel.NONE);
+      
+      debug.trace('trace message');
+      debug.debug('debug message');
+      debug.info('info message');
+      debug.warn('warn message');
+      debug.error('error message');
+
+      expect(logger.debug).not.toHaveBeenCalled();
+      expect(logger.info).not.toHaveBeenCalled();
+      expect(logger.warn).not.toHaveBeenCalled();
+      expect(logger.error).not.toHaveBeenCalled();
+    });
+
+    it('should only log errors when level is ERROR', () => {
+      __setMockDebugLevel(DebugLevel.ERROR);
+      
+      debug.trace('trace message');
+      debug.debug('debug message');
+      debug.info('info message');
+      debug.warn('warn message');
+      debug.error('error message');
+
+      expect(logger.debug).not.toHaveBeenCalled();
+      expect(logger.info).not.toHaveBeenCalled();
+      expect(logger.warn).not.toHaveBeenCalled();
+      expect(logger.error).toHaveBeenCalledTimes(1);
+    });
+
+    it('should log warnings and errors when level is WARN', () => {
+      __setMockDebugLevel(DebugLevel.WARN);
+      
+      debug.trace('trace message');
+      debug.debug('debug message');
+      debug.info('info message');
+      debug.warn('warn message');
+      debug.error('error message');
+
+      expect(logger.debug).not.toHaveBeenCalled();
+      expect(logger.info).not.toHaveBeenCalled();
+      expect(logger.warn).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledTimes(1);
+    });
+
+    it('should log info, warnings, and errors when level is INFO', () => {
+      __setMockDebugLevel(DebugLevel.INFO);
+      
+      debug.trace('trace message');
+      debug.debug('debug message');
+      debug.info('info message');
+      debug.warn('warn message');
+      debug.error('error message');
+
+      expect(logger.debug).not.toHaveBeenCalled();
+      expect(logger.info).toHaveBeenCalledTimes(1);
+      expect(logger.warn).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledTimes(1);
+    });
+
+    it('should log debug, info, warnings, and errors when level is DEBUG', () => {
+      __setMockDebugLevel(DebugLevel.DEBUG);
+      
+      debug.trace('trace message');
+      debug.debug('debug message');
+      debug.info('info message');
+      debug.warn('warn message');
+      debug.error('error message');
+
+      expect(logger.debug).toHaveBeenCalledTimes(1); // debug only
+      expect(logger.info).toHaveBeenCalledTimes(1);
+      expect(logger.warn).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledTimes(1);
+    });
+
+    it('should log everything including trace when level is TRACE', () => {
+      __setMockDebugLevel(DebugLevel.TRACE);
+      
+      debug.trace('trace message');
+      debug.debug('debug message');
+      debug.info('info message');
+      debug.warn('warn message');
+      debug.error('error message');
+
+      expect(logger.debug).toHaveBeenCalledTimes(2); // trace + debug
+      expect(logger.info).toHaveBeenCalledTimes(1);
+      expect(logger.warn).toHaveBeenCalledTimes(1);
+      expect(logger.error).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Context Propagation', () => {
+    it('should include context in all log calls', () => {
+      __setMockDebugLevel(DebugLevel.DEBUG);
+      
+      debug.debug('test message', { extra: 'data' });
+
+      expect(logger.debug).toHaveBeenCalledWith(
+        '[DEBUG] test message',
+        expect.objectContaining({
+          tool: 'test_tool',
+          userId: 'user123',
+          operation: 'test_operation',
+          extra: 'data',
+          debugLevel: 'DEBUG',
+        })
+      );
+    });
+  });
+
+  describe('dump()', () => {
+    it('should only dump objects at TRACE level', () => {
+      __setMockDebugLevel(DebugLevel.DEBUG);
+      
+      debug.dump('test object', { foo: 'bar' });
+      expect(logger.debug).not.toHaveBeenCalled();
+
+      __setMockDebugLevel(DebugLevel.TRACE);
+      debug.dump('test object', { foo: 'bar' });
+      
+      expect(logger.debug).toHaveBeenCalledWith(
+        '[DUMP] test object',
+        expect.objectContaining({
+          dump: expect.stringContaining('"foo": "bar"'),
+        })
+      );
+    });
+  });
+
+  describe('time()', () => {
+    it('should not add timing overhead when debug is disabled', async () => {
+      __setMockDebugLevel(DebugLevel.NONE);
+      
+      const result = await debug.time('test operation', async () => {
+        return 'result';
+      });
+
+      expect(result).toBe('result');
+      expect(logger.debug).not.toHaveBeenCalled();
+    });
+
+    it('should log timing when DEBUG level is enabled', async () => {
+      __setMockDebugLevel(DebugLevel.DEBUG);
+      
+      const result = await debug.time('test operation', async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return 'result';
+      });
+
+      expect(result).toBe('result');
+      expect(logger.debug).toHaveBeenCalledWith(
+        '[DEBUG] test operation - Starting',
+        expect.any(Object)
+      );
+      expect(logger.debug).toHaveBeenCalledWith(
+        '[DEBUG] test operation - Completed',
+        expect.objectContaining({
+          durationMs: expect.any(Number),
+        })
+      );
+    });
+
+    it('should log errors with timing on failure', async () => {
+      __setMockDebugLevel(DebugLevel.DEBUG);
+      
+      const error = new Error('test error');
+      
+      await expect(
+        debug.time('test operation', async () => {
+          throw error;
+        })
+      ).rejects.toThrow('test error');
+
+      expect(logger.error).toHaveBeenCalledWith(
+        '[ERROR] test operation - Failed',
+        expect.objectContaining({
+          durationMs: expect.any(Number),
+          error: 'test error',
+        })
+      );
+    });
+  });
+
+  describe('createDebugLogger()', () => {
+    it('should create a DebugLogger instance with context', () => {
+      const logger = createDebugLogger({
+        tool: 'test_tool',
+        userId: 'user123',
+      });
+
+      expect(logger).toBeInstanceOf(DebugLogger);
+    });
+  });
+});