@prmichaelsen/remember-mcp 2.2.1 → 2.3.1

package/src/tools/confirm.ts

@@ -0,0 +1,219 @@
+/**
+ * remember_confirm tool
+ * 
+ * Generic confirmation tool that executes any pending action.
+ * This is the second phase of the confirmation workflow.
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { confirmationTokenService, type ConfirmationRequest } from '../services/confirmation-token.service.js';
+import { getWeaviateClient, getMemoryCollectionName } from '../weaviate/client.js';
+import { ensureSpaceCollection } from '../weaviate/space-schema.js';
+import { handleToolError } from '../utils/error-handler.js';
+
+/**
+ * Tool definition for remember_confirm
+ */
+export const confirmTool: Tool = {
+  name: 'remember_confirm',
+  description: 'Confirm and execute a pending action using the token. Works for any action that requires confirmation (publish, delete, etc.).',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      token: {
+        type: 'string',
+        description: 'The confirmation token from the action tool',
+      },
+    },
+    required: ['token'],
+  },
+};
+
+interface ConfirmArgs {
+  token: string;
+}
+
+/**
+ * Handle remember_confirm tool execution
+ */
+export async function handleConfirm(
+  args: ConfirmArgs,
+  userId: string
+): Promise<string> {
+  try {
+    console.log('[remember_confirm] Starting confirmation:', {
+      userId,
+      token: args.token,
+    });
+    
+    // Validate and confirm token
+    const request = await confirmationTokenService.confirmRequest(userId, args.token);
+    
+    console.log('[remember_confirm] Token validation result:', {
+      requestFound: !!request,
+      action: request?.action,
+    });
+
+    if (!request) {
+      console.log('[remember_confirm] Token invalid or expired');
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Invalid or expired token',
+          message: 'The confirmation token is invalid, expired, or has already been used.',
+        },
+        null,
+        2
+      );
+    }
+
+    console.log('[remember_confirm] Executing action:', request.action);
+
+    // GENERIC: Execute action based on type
+    // This is where the generic pattern delegates to action-specific executors
+    if (request.action === 'publish_memory') {
+      return await executePublishMemory(request, userId);
+    }
+
+    // Add other action types here as needed
+    // if (request.action === 'retract_memory') {
+    //   return await executeRetractMemory(request, userId);
+    // }
+
+    throw new Error(`Unknown action type: ${request.action}`);
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_confirm',
+      userId,
+      operation: 'confirm action',
+      token: args.token,
+    });
+  }
+}
+
+/**
+ * Execute publish memory action
+ */
+async function executePublishMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string
+): Promise<string> {
+  try {
+    console.log('[executePublishMemory] Starting execution:', {
+      userId,
+      memoryId: request.payload.memory_id,
+      targetSpace: request.target_collection,
+    });
+    
+    // Fetch the memory NOW (during confirmation, not from stored payload)
+    const weaviateClient = getWeaviateClient();
+    const userCollection = weaviateClient.collections.get(
+      getMemoryCollectionName(userId)
+    );
+    
+    console.log('[executePublishMemory] Fetching original memory from:', getMemoryCollectionName(userId));
+
+    const originalMemory = await userCollection.query.fetchObjectById(
+      request.payload.memory_id
+    );
+    
+    console.log('[executePublishMemory] Original memory fetch result:', {
+      found: !!originalMemory,
+      memoryId: request.payload.memory_id,
+    });
+
+    if (!originalMemory) {
+      console.log('[executePublishMemory] Memory not found');
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Memory not found',
+          message: `Original memory ${request.payload.memory_id} no longer exists`,
+        },
+        null,
+        2
+      );
+    }
+
+    // Verify ownership again
+    if (originalMemory.properties.user_id !== userId) {
+      console.log('[executePublishMemory] Permission denied - wrong owner');
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Permission denied',
+          message: 'You can only publish your own memories',
+        },
+        null,
+        2
+      );
+    }
+    
+    console.log('[executePublishMemory] Ensuring space collection:', request.target_collection || 'the_void');
+
+    // Get target collection
+    const targetCollection = await ensureSpaceCollection(
+      weaviateClient,
+      request.target_collection || 'the_void'
+    );
+    
+    console.log('[executePublishMemory] Space collection ready');
+
+    // Create published memory (copy with modifications)
+    const originalTags = Array.isArray(originalMemory.properties.tags)
+      ? originalMemory.properties.tags
+      : [];
+    const additionalTags = Array.isArray(request.payload.additional_tags)
+      ? request.payload.additional_tags
+      : [];
+
+    const publishedMemory = {
+      ...originalMemory.properties,
+      // Override specific fields
+      space_id: request.target_collection || 'the_void',
+      author_id: userId, // Always attributed
+      published_at: new Date().toISOString(),
+      discovery_count: 0,
+      doc_type: 'space_memory',
+      attribution: 'user' as const,
+      // Merge additional tags
+      tags: [...originalTags, ...additionalTags],
+      // Update timestamps
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      version: 1,
+    };
+
+    console.log('[executePublishMemory] Inserting into space collection:', {
+      spaceId: request.target_collection || 'the_void',
+      memoryId: request.payload.memory_id,
+      hasProperties: !!publishedMemory,
+    });
+    
+    const result = await targetCollection.data.insert({
+      properties: publishedMemory as any,
+    });
+    
+    console.log('[executePublishMemory] Insert result:', {
+      success: !!result,
+      spaceMemoryId: result,
+    });
+
+    // Return minimal response - agent already knows original memory
+    return JSON.stringify(
+      {
+        success: true,
+        space_memory_id: result,
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_confirm',
+      userId,
+      operation: 'execute publish_memory',
+      action: 'publish_memory',
+    });
+  }
+}

package/src/tools/create-memory.ts

@@ -20,6 +20,13 @@ export const createMemoryTool = {
   Each memory has a weight (significance 0-1) and trust level (access control 0-1).
   Location and context are automatically captured from the request.
   
+  **IMPORTANT - Content vs Summary**:
+  - **content**: MUST be EXACT user-provided text. DO NOT paraphrase or modify.
+  - **summary**: Use for AI-generated summaries or interpretations.
+  - Example: User says "Remember: Meeting at 3pm tomorrow"
+    → content: "Meeting at 3pm tomorrow" (EXACT)
+    → summary: "User has meeting on 2026-02-17 at 15:00" (AI interpretation)
+  
   Examples:
   - "Remember that I met Sarah at the conference"
   - "Save this recipe for chocolate chip cookies"

package/src/tools/deny.ts

@@ -0,0 +1,70 @@
+/**
+ * remember_deny tool
+ * 
+ * Generic denial tool for any pending action.
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { confirmationTokenService } from '../services/confirmation-token.service.js';
+import { handleToolError } from '../utils/error-handler.js';
+
+/**
+ * Tool definition for remember_deny
+ */
+export const denyTool: Tool = {
+  name: 'remember_deny',
+  description: 'Deny a pending action. The request will be marked as denied and the token invalidated. Works for any action that requires confirmation.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      token: {
+        type: 'string',
+        description: 'The confirmation token from the action tool',
+      },
+    },
+    required: ['token'],
+  },
+};
+
+interface DenyArgs {
+  token: string;
+}
+
+/**
+ * Handle remember_deny tool execution
+ */
+export async function handleDeny(
+  args: DenyArgs,
+  userId: string
+): Promise<string> {
+  try {
+    const success = await confirmationTokenService.denyRequest(userId, args.token);
+
+    if (!success) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Invalid token',
+          message: 'Token not found or already used',
+        },
+        null,
+        2
+      );
+    }
+
+    return JSON.stringify(
+      {
+        success: true,
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_deny',
+      userId,
+      operation: 'deny action',
+      token: args.token,
+    });
+  }
+}

package/src/tools/publish.ts

@@ -0,0 +1,190 @@
+/**
+ * remember_publish tool
+ * 
+ * Generates a confirmation token for publishing a memory to a shared space.
+ * This is the first phase of the two-phase publish workflow.
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { confirmationTokenService } from '../services/confirmation-token.service.js';
+import { getWeaviateClient, getMemoryCollectionName } from '../weaviate/client.js';
+import { isValidSpaceId } from '../weaviate/space-schema.js';
+import { handleToolError } from '../utils/error-handler.js';
+import { SUPPORTED_SPACES } from '../types/space-memory.js';
+
+/**
+ * Tool definition for remember_publish
+ */
+export const publishTool: Tool = {
+  name: 'remember_publish',
+  description: 'Publish a memory to a shared space (like "The Void"). The memory will be COPIED (not moved) from your personal collection. Generates a confirmation token. Use remember_confirm to execute.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      memory_id: {
+        type: 'string',
+        description: 'ID of the memory from your personal collection to publish',
+      },
+      target: {
+        type: 'string',
+        description: 'Target space to publish to (snake_case ID)',
+        enum: SUPPORTED_SPACES,
+        default: 'the_void',
+      },
+      additional_tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Additional tags for discovery (merged with original tags)',
+        default: [],
+      },
+    },
+    required: ['memory_id', 'target'],
+  },
+};
+
+interface PublishArgs {
+  memory_id: string;
+  target: string;
+  additional_tags?: string[];
+}
+
+/**
+ * Handle remember_publish tool execution
+ */
+export async function handlePublish(
+  args: PublishArgs,
+  userId: string
+): Promise<string> {
+  try {
+    console.log('[remember_publish] Starting publish request:', {
+      userId,
+      memoryId: args.memory_id,
+      target: args.target,
+      additionalTags: args.additional_tags?.length || 0,
+    });
+    
+    // Validate space ID
+    if (!isValidSpaceId(args.target)) {
+      console.log('[remember_publish] Invalid space ID:', args.target);
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Invalid space ID',
+          message: `Space "${args.target}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
+          context: {
+            provided_space: args.target,
+            supported_spaces: SUPPORTED_SPACES,
+          },
+        },
+        null,
+        2
+      );
+    }
+
+    // Verify memory exists and user owns it
+    const weaviateClient = getWeaviateClient();
+    const collectionName = getMemoryCollectionName(userId);
+    console.log('[remember_publish] Fetching memory from collection:', collectionName);
+    
+    const userCollection = weaviateClient.collections.get(collectionName);
+
+    const memory = await userCollection.query.fetchObjectById(args.memory_id);
+    
+    console.log('[remember_publish] Memory fetch result:', {
+      found: !!memory,
+      memoryId: args.memory_id,
+    });
+
+    if (!memory) {
+      console.log('[remember_publish] Memory not found');
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Memory not found',
+          message: `No memory found with ID: ${args.memory_id}`,
+          context: {
+            collection_name: getMemoryCollectionName(userId),
+            memory_id: args.memory_id,
+          },
+        },
+        null,
+        2
+      );
+    }
+
+    // Verify ownership
+    if (memory.properties.user_id !== userId) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Permission denied',
+          message: 'You can only publish your own memories',
+          context: {
+            memory_id: args.memory_id,
+            memory_owner: memory.properties.user_id,
+            requesting_user: userId,
+          },
+        },
+        null,
+        2
+      );
+    }
+
+    // Verify it's a memory (not a relationship)
+    if (memory.properties.doc_type !== 'memory') {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Invalid document type',
+          message: 'Only memories can be published (not relationships)',
+          context: {
+            memory_id: args.memory_id,
+            doc_type: memory.properties.doc_type,
+          },
+        },
+        null,
+        2
+      );
+    }
+
+    // Create payload with only memory_id (content fetched during confirmation)
+    const payload = {
+      memory_id: args.memory_id,
+      additional_tags: args.additional_tags || [],
+    };
+
+    console.log('[remember_publish] Generating confirmation token');
+    
+    // Generate confirmation token
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      'publish_memory',
+      payload,
+      args.target
+    );
+    
+    console.log('[remember_publish] Token generated:', {
+      requestId,
+      token,
+      action: 'publish_memory',
+    });
+
+    // Return minimal response - agent already knows memory details
+    return JSON.stringify(
+      {
+        success: true,
+        token,
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_publish',
+      userId,
+      operation: 'publish memory',
+      memory_id: args.memory_id,
+      target: args.target,
+    });
+  }
+}

package/src/tools/query-space.ts

@@ -0,0 +1,197 @@
+/**
+ * remember_query_space tool
+ * 
+ * RAG-optimized natural language queries for shared spaces.
+ * Similar to remember_query_memory but queries space collections.
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { Filters } from 'weaviate-client';
+import { getWeaviateClient } from '../weaviate/client.js';
+import { ensureSpaceCollection, isValidSpaceId } from '../weaviate/space-schema.js';
+import { SUPPORTED_SPACES } from '../types/space-memory.js';
+import { handleToolError } from '../utils/error-handler.js';
+
+/**
+ * Tool definition for remember_query_space
+ */
+export const querySpaceTool: Tool = {
+  name: 'remember_query_space',
+  description: 'Ask natural language questions about memories in shared spaces. Works like remember_query_memory but queries shared spaces.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      question: {
+        type: 'string',
+        description: 'Natural language question',
+      },
+      space: {
+        type: 'string',
+        description: 'Which space to query',
+        enum: SUPPORTED_SPACES,
+        default: 'the_void',
+      },
+      content_type: {
+        type: 'string',
+        description: 'Filter by content type',
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Filter by tags',
+      },
+      min_weight: {
+        type: 'number',
+        minimum: 0,
+        maximum: 1,
+        description: 'Minimum weight/significance (0-1)',
+      },
+      date_from: {
+        type: 'string',
+        description: 'Filter memories created after this date (ISO 8601)',
+      },
+      date_to: {
+        type: 'string',
+        description: 'Filter memories created before this date (ISO 8601)',
+      },
+      limit: {
+        type: 'number',
+        default: 10,
+        description: 'Maximum number of results',
+      },
+      format: {
+        type: 'string',
+        enum: ['detailed', 'compact'],
+        default: 'detailed',
+        description: 'Output format: detailed (full objects) or compact (text summary)',
+      },
+    },
+    required: ['question', 'space'],
+  },
+};
+
+interface QuerySpaceArgs {
+  question: string;
+  space: string;
+  content_type?: string;
+  tags?: string[];
+  min_weight?: number;
+  date_from?: string;
+  date_to?: string;
+  limit?: number;
+  format?: 'detailed' | 'compact';
+}
+
+/**
+ * Handle remember_query_space tool execution
+ */
+export async function handleQuerySpace(
+  args: QuerySpaceArgs,
+  userId: string  // May be used for private spaces in future
+): Promise<string> {
+  try {
+    // Validate space ID
+    if (!isValidSpaceId(args.space)) {
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Invalid space ID',
+          message: `Space "${args.space}" is not supported. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
+        },
+        null,
+        2
+      );
+    }
+
+    const weaviateClient = getWeaviateClient();
+    const spaceCollection = await ensureSpaceCollection(weaviateClient, args.space);
+
+    // Build filters
+    const filterList: any[] = [];
+
+    // Filter by space_id
+    filterList.push(spaceCollection.filter.byProperty('space_id').equal(args.space));
+
+    // Filter by doc_type (space_memory)
+    filterList.push(spaceCollection.filter.byProperty('doc_type').equal('space_memory'));
+
+    // Apply content type filter
+    if (args.content_type) {
+      filterList.push(spaceCollection.filter.byProperty('type').equal(args.content_type));
+    }
+
+    // Apply tags filter
+    if (args.tags && args.tags.length > 0) {
+      args.tags.forEach(tag => {
+        filterList.push(spaceCollection.filter.byProperty('tags').containsAny([tag]));
+      });
+    }
+
+    // Apply weight filter
+    if (args.min_weight !== undefined) {
+      filterList.push(spaceCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
+    }
+
+    // Apply date filters
+    if (args.date_from) {
+      filterList.push(spaceCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
+    }
+
+    if (args.date_to) {
+      filterList.push(spaceCollection.filter.byProperty('created_at').lessOrEqual(new Date(args.date_to)));
+    }
+
+    const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
+
+    // Execute semantic search using nearText
+    const searchResults = await spaceCollection.query.nearText(args.question, {
+      limit: args.limit || 10,
+      ...(whereFilter && { where: whereFilter }),
+    });
+
+    // Format results based on requested format
+    const format = args.format || 'detailed';
+
+    if (format === 'compact') {
+      // Compact format: text summary for LLM context
+      const summaries = searchResults.objects.map((obj, idx) => {
+        const props = obj.properties;
+        return `${idx + 1}. ${props.title || props.content?.substring(0, 100) || 'Untitled'}`;
+      });
+
+      const result = {
+        question: args.question,
+        space: args.space,
+        format: 'compact',
+        summary: summaries.join('\n'),
+        count: searchResults.objects.length,
+      };
+
+      return JSON.stringify(result, null, 2);
+    } else {
+      // Detailed format: full objects
+      const memories = searchResults.objects.map((obj) => ({
+        id: obj.uuid,
+        ...obj.properties,
+        _distance: obj.metadata?.distance,
+      }));
+
+      const result = {
+        question: args.question,
+        space: args.space,
+        format: 'detailed',
+        memories,
+        total: memories.length,
+      };
+
+      return JSON.stringify(result, null, 2);
+    }
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_query_space',
+      operation: 'query space',
+      space: args.space,
+      question: args.question,
+    });
+  }
+}