@prmichaelsen/remember-mcp 2.7.10 → 2.8.0

package/dist/server.js

@@ -479,12 +479,36 @@ function validateConfig() {
     });
   });
 }
-var import_dotenv, config;
+var import_dotenv, debugConfig, config;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     import_dotenv = __toESM(require_main(), 1);
     import_dotenv.default.config();
+    debugConfig = {
+      level: (() => {
+        const level = process.env.REMEMBER_MCP_DEBUG_LEVEL?.toUpperCase();
+        switch (level) {
+          case "TRACE":
+            return 5 /* TRACE */;
+          case "DEBUG":
+            return 4 /* DEBUG */;
+          case "INFO":
+            return 3 /* INFO */;
+          case "WARN":
+            return 2 /* WARN */;
+          case "ERROR":
+            return 1 /* ERROR */;
+          case "NONE":
+            return 0 /* NONE */;
+          default:
+            return 0 /* NONE */;
+        }
+      })(),
+      enabled: (level) => {
+        return debugConfig.level >= level;
+      }
+    };
     config = {
       // Weaviate
       weaviate: {
@@ -538,6 +562,103 @@ import {
 init_config();
 init_logger();
 import weaviate from "weaviate-client";
+
+// src/utils/debug.ts
+init_config();
+init_logger();
+var DebugLogger = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  trace(message, data) {
+    if (debugConfig.enabled(5 /* TRACE */)) {
+      logger.debug(`[TRACE] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "TRACE"
+      });
+    }
+  }
+  debug(message, data) {
+    if (debugConfig.enabled(4 /* DEBUG */)) {
+      logger.debug(`[DEBUG] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "DEBUG"
+      });
+    }
+  }
+  info(message, data) {
+    if (debugConfig.enabled(3 /* INFO */)) {
+      logger.info(`[INFO] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "INFO"
+      });
+    }
+  }
+  warn(message, data) {
+    if (debugConfig.enabled(2 /* WARN */)) {
+      logger.warn(`[WARN] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "WARN"
+      });
+    }
+  }
+  error(message, data) {
+    if (debugConfig.enabled(1 /* ERROR */)) {
+      logger.error(`[ERROR] ${message}`, {
+        ...this.context,
+        ...data,
+        debugLevel: "ERROR"
+      });
+    }
+  }
+  /**
+   * Dump full object (TRACE only)
+   * Use with caution - may expose sensitive data
+   */
+  dump(label, obj) {
+    if (debugConfig.enabled(5 /* TRACE */)) {
+      logger.debug(`[DUMP] ${label}`, {
+        ...this.context,
+        dump: JSON.stringify(obj, null, 2),
+        debugLevel: "TRACE"
+      });
+    }
+  }
+  /**
+   * Time an async operation (DEBUG and above)
+   * Logs start, completion, and duration
+   */
+  async time(label, fn) {
+    if (!debugConfig.enabled(4 /* DEBUG */)) {
+      return fn();
+    }
+    const start = Date.now();
+    this.debug(`${label} - Starting`);
+    try {
+      const result = await fn();
+      const duration = Date.now() - start;
+      this.debug(`${label} - Completed`, { durationMs: duration });
+      return result;
+    } catch (error) {
+      const duration = Date.now() - start;
+      this.error(`${label} - Failed`, {
+        durationMs: duration,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+};
+function createDebugLogger(context) {
+  return new DebugLogger(context);
+}
+
+// src/weaviate/client.ts
 var client = null;
 async function initWeaviateClient() {
   if (client) {
@@ -660,20 +781,52 @@ var ALL_MEMORY_PROPERTIES = [
   // Comment/threading fields
   "parent_id",
   "thread_root_id",
-  "moderation_flags"
+  "moderation_flags",
+  // Space/publishing fields (for Memory_public collection)
+  "spaces",
+  "space_id",
+  "author_id",
+  "ghost_id",
+  "attribution",
+  "published_at",
+  "discovery_count",
+  "space_memory_id"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
+  const debug = createDebugLogger({
+    tool: "weaviate-client",
+    operation: "fetchMemoryWithAllProperties"
+  });
+  debug.debug("Fetching memory", {
+    memoryId,
+    collectionName: collection.name,
+    propertyCount: ALL_MEMORY_PROPERTIES.length
+  });
   try {
-    return await collection.query.fetchObjectById(memoryId, {
-      returnProperties: ALL_MEMORY_PROPERTIES
+    const result = await debug.time("Fetch with all properties", async () => {
+      return await collection.query.fetchObjectById(memoryId, {
+        returnProperties: ALL_MEMORY_PROPERTIES
+      });
+    });
+    debug.trace("Fetch result", {
+      found: !!result,
+      propertyCount: result?.properties ? Object.keys(result.properties).length : 0,
+      hasSpaces: !!result?.properties?.spaces,
+      hasAuthorId: !!result?.properties?.author_id
     });
+    return result;
   } catch (error) {
+    debug.warn("Fetch with all properties failed, falling back", {
+      error: error instanceof Error ? error.message : String(error)
+    });
     logger.warn("Failed to fetch with all properties, falling back to unspecified fetch", {
       module: "weaviate-client",
       memoryId,
       error: error instanceof Error ? error.message : String(error)
     });
-    return await collection.query.fetchObjectById(memoryId);
+    return await debug.time("Fetch without property specification", async () => {
+      return await collection.query.fetchObjectById(memoryId);
+    });
   }
 }
 
@@ -4073,7 +4226,14 @@ var publishTool = {
   }
 };
 async function handlePublish(args, userId) {
+  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,
@@ -4082,8 +4242,10 @@ async function handlePublish(args, userId) {
       spaceCount: args.spaces.length,
       additionalTags: args.additional_tags?.length || 0
     });
+    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,
@@ -4127,7 +4289,9 @@ async function handlePublish(args, userId) {
       memoryId: args.memory_id
     });
     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",
       found: !!memory,
@@ -4222,6 +4386,10 @@ async function handlePublish(args, userId) {
       2
     );
   } catch (error) {
+    debug.error("Tool failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
     return handleToolError(error, {
       toolName: "remember_publish",
       userId,
@@ -4259,13 +4427,23 @@ Violating these requirements bypasses user consent and is a security violation.`
   }
 };
 async function handleConfirm(args, userId) {
+  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,
       token: args.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",
       requestFound: !!request,
@@ -4296,6 +4474,10 @@ async function handleConfirm(args, userId) {
     }
     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 : void 0
+    });
     handleToolError(error, {
       toolName: "remember_confirm",
       userId,
@@ -4305,7 +4487,16 @@ async function handleConfirm(args, userId) {
   }
 }
 async function executePublishMemory(request, userId) {
+  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,
@@ -4322,10 +4513,12 @@ async function executePublishMemory(request, userId) {
       collectionName: getMemoryCollectionName(userId),
       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",
       found: !!originalMemory,
@@ -4356,6 +4549,26 @@ async function executePublishMemory(request, userId) {
         2
       );
     }
+    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
+      );
+    }
     if (originalMemory.properties.user_id !== userId) {
       logger.warn("Permission denied - wrong owner", {
         function: "executePublishMemory",
@@ -4415,14 +4628,20 @@ async function executePublishMemory(request, userId) {
       contentLength: publishedMemory.content?.length || 0,
       titleValue: publishedMemory.title || "NO_TITLE"
     });
-    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", {
       function: "executePublishMemory",
       spaceMemoryId: result,
       spaces: request.payload.spaces
     });
+    debug.info("Memory published successfully", {
+      spaceMemoryId: result,
+      spaces: request.payload.spaces
+    });
     try {
       await userCollection.data.update({
         id: request.payload.memory_id,
@@ -4453,6 +4672,10 @@ async function executePublishMemory(request, userId) {
       2
     );
   } catch (error) {
+    debug.error("Execute publish failed", {
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
     handleToolError(error, {
       toolName: "remember_confirm",
       userId,
@@ -4597,7 +4820,15 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
   }
 };
 async function handleSearchSpace(args, userId) {
+  const debug = createDebugLogger({
+    tool: "remember_search_space",
+    userId,
+    operation: "search_spaces"
+  });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
+    debug.debug("Validating space IDs", { spaces: args.spaces });
     const invalidSpaces = args.spaces.filter((s) => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
       return JSON.stringify(
@@ -4655,10 +4886,21 @@ async function handleSearchSpace(args, userId) {
       filterList.push(publicCollection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
     }
     const whereFilter = filterList.length > 0 ? Filters3.and(...filterList) : void 0;
-    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 }
+      offset: args.offset || 0
+    });
+    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
     });
     const memories = searchResults.objects.map((obj) => ({
       id: obj.uuid,
@@ -4673,8 +4915,16 @@ async function handleSearchSpace(args, userId) {
       offset: args.offset || 0,
       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 : void 0
+    });
     return handleToolError(error, {
       toolName: "remember_search_space",
       operation: "search spaces",
@@ -4758,7 +5008,15 @@ Let the query algorithm find ALL relevant memories regardless of type unless exp
   }
 };
 async function handleQuerySpace(args, userId) {
+  const debug = createDebugLogger({
+    tool: "remember_query_space",
+    userId,
+    operation: "query_spaces"
+  });
   try {
+    debug.info("Tool invoked");
+    debug.trace("Arguments", { args });
+    debug.debug("Validating space IDs", { spaces: args.spaces });
     const invalidSpaces = args.spaces.filter((s) => !isValidSpaceId(s));
     if (invalidSpaces.length > 0) {
       return JSON.stringify(
@@ -4808,9 +5066,20 @@ async function handleQuerySpace(args, userId) {
       filterList.push(publicCollection.filter.byProperty("created_at").lessOrEqual(new Date(args.date_to)));
     }
     const whereFilter = filterList.length > 0 ? Filters4.and(...filterList) : void 0;
-    const searchResults = await publicCollection.query.nearText(args.question, {
-      limit: args.limit || 10,
-      ...whereFilter && { where: whereFilter }
+    debug.debug("Executing semantic query", {
+      question: args.question,
+      filterCount: filterList.length,
+      limit: args.limit || 10
+    });
+    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"
     });
     const format = args.format || "detailed";
     if (format === "compact") {
@@ -4839,9 +5108,17 @@ async function handleQuerySpace(args, userId) {
         memories,
         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 : void 0
+    });
     return handleToolError(error, {
       toolName: "remember_query_space",
       operation: "query spaces",

package/dist/utils/debug.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Debug logging utility for remember-mcp
+ *
+ * Provides configurable debug logging via REMEMBER_MCP_DEBUG_LEVEL environment variable.
+ * Levels: NONE (default), ERROR, WARN, INFO, DEBUG, TRACE
+ */
+export interface DebugContext {
+    tool: string;
+    userId?: string;
+    operation?: string;
+    [key: string]: any;
+}
+export declare class DebugLogger {
+    private context;
+    constructor(context: DebugContext);
+    trace(message: string, data?: any): void;
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+    /**
+     * Dump full object (TRACE only)
+     * Use with caution - may expose sensitive data
+     */
+    dump(label: string, obj: any): void;
+    /**
+     * Time an async operation (DEBUG and above)
+     * Logs start, completion, and duration
+     */
+    time<T>(label: string, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Create a debug logger with context
+ *
+ * @param context - Context information (tool name, userId, operation, etc.)
+ * @returns DebugLogger instance
+ *
+ * @example
+ * const debug = createDebugLogger({
+ *   tool: 'remember_create_memory',
+ *   userId: 'user123',
+ *   operation: 'create',
+ * });
+ *
+ * debug.info('Tool invoked');
+ * debug.trace('Arguments', { args });
+ * const result = await debug.time('Database operation', async () => {
+ *   return await collection.insert(data);
+ * });
+ */
+export declare function createDebugLogger(context: DebugContext): DebugLogger;
+//# sourceMappingURL=debug.d.ts.map

package/dist/utils/debug.spec.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for debug utility
+ */
+export {};
+//# sourceMappingURL=debug.spec.d.ts.map

package/dist/weaviate/client.d.ts

@@ -41,7 +41,7 @@ export declare function getAuditCollectionName(userId: string): string;
  * List of all memory properties to fetch
  * Matches the actual Weaviate schema properties exactly
  */
-export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "content", "title", "summary", "type", "weight", "base_weight", "trust", "confidence", "computed_weight", "location_gps_lat", "location_gps_lng", "location_address", "location_city", "location_country", "location_source", "locale_language", "locale_timezone", "context_conversation_id", "context_summary", "context_timestamp", "relationships", "access_count", "last_accessed_at", "tags", "references", "created_at", "updated_at", "version", "template_id", "memory_ids", "relationship_type", "observation", "strength", "parent_id", "thread_root_id", "moderation_flags"];
+export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "content", "title", "summary", "type", "weight", "base_weight", "trust", "confidence", "computed_weight", "location_gps_lat", "location_gps_lng", "location_address", "location_city", "location_country", "location_source", "locale_language", "locale_timezone", "context_conversation_id", "context_summary", "context_timestamp", "relationships", "access_count", "last_accessed_at", "tags", "references", "created_at", "updated_at", "version", "template_id", "memory_ids", "relationship_type", "observation", "strength", "parent_id", "thread_root_id", "moderation_flags", "spaces", "space_id", "author_id", "ghost_id", "attribution", "published_at", "discovery_count", "space_memory_id"];
 /**
  * Fetch a memory object by ID with all properties
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "2.7.10",
+  "version": "2.8.0",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/config.ts

@@ -3,6 +3,39 @@ import { logger } from './utils/logger.js';
 
 dotenv.config();
 
+/**
+ * Debug levels for tool logging
+ */
+export enum DebugLevel {
+  NONE = 0,      // No debug output (production default)
+  ERROR = 1,     // Only errors
+  WARN = 2,      // Warnings and errors
+  INFO = 3,      // Info, warnings, and errors
+  DEBUG = 4,     // Debug, info, warnings, and errors
+  TRACE = 5,     // Everything including parameter dumps
+}
+
+/**
+ * Debug configuration
+ */
+export const debugConfig = {
+  level: ((): DebugLevel => {
+    const level = process.env.REMEMBER_MCP_DEBUG_LEVEL?.toUpperCase();
+    switch (level) {
+      case 'TRACE': return DebugLevel.TRACE;
+      case 'DEBUG': return DebugLevel.DEBUG;
+      case 'INFO': return DebugLevel.INFO;
+      case 'WARN': return DebugLevel.WARN;
+      case 'ERROR': return DebugLevel.ERROR;
+      case 'NONE': return DebugLevel.NONE;
+      default: return DebugLevel.NONE;
+    }
+  })(),
+  enabled: (level: DebugLevel): boolean => {
+    return debugConfig.level >= level;
+  },
+};
+
 export const config = {
   // Weaviate
   weaviate: {