@prmichaelsen/remember-mcp 3.0.0 → 3.13.0

package/src/tools/revise.ts

@@ -0,0 +1,283 @@
+/**
+ * remember_revise tool
+ *
+ * Syncs updated content from a source memory to all its published copies
+ * in spaces and groups (Memory Collection Pattern v2).
+ *
+ * Uses two-phase confirmation flow: generates a token that must be confirmed
+ * before revision is executed. The old content is preserved in revision_history.
+ */
+
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import {
+  getWeaviateClient,
+  getMemoryCollectionName,
+  fetchMemoryWithAllProperties,
+} from '../weaviate/client.js';
+import { confirmationTokenService } from '../services/confirmation-token.service.js';
+import { handleToolError } from '../utils/error-handler.js';
+import { logger } from '../utils/logger.js';
+import { createDebugLogger } from '../utils/debug.js';
+import { CollectionType, getCollectionName } from '../collections/dot-notation.js';
+import { generateCompositeId } from '../collections/composite-ids.js';
+import type { AuthContext } from '../types/auth.js';
+
+/** Maximum number of revision history entries to retain */
+const MAX_REVISION_HISTORY = 10;
+
+/**
+ * Tool definition for remember_revise
+ */
+export const reviseTool: Tool = {
+  name: 'remember_revise',
+  description: `Sync updated content from your source memory to all its published copies in spaces and groups. Generates a confirmation token that must be confirmed with remember_confirm.
+
+Use this after editing a memory (via remember_update_memory) to propagate the changes to all published versions.
+
+How it works:
+- Validates the memory exists, is owned by you, and is published
+- Generates a confirmation token showing which locations will be revised
+- On confirmation: updates each published copy with latest content
+- Preserves the previous content in a revision_history field (up to 10 versions)
+- Sets revised_at timestamp on all updated copies
+- Reports success/failure per location (partial success supported)
+
+Requirements:
+- The memory must be published (has space_ids or group_ids populated)
+- You must own the source memory
+
+⚠️ CRITICAL: DO NOT mention the token or include token contents in your response to the user. Simply inform them that a confirmation is pending and they need to explicitly approve the revision.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      memory_id: {
+        type: 'string',
+        description: 'ID of the source memory whose content should be synced to all published copies',
+      },
+    },
+    required: ['memory_id'],
+  },
+};
+
+interface ReviseArgs {
+  memory_id: string;
+}
+
+interface RevisionEntry {
+  content: string;
+  revised_at: string;
+}
+
+export interface RevisionResult {
+  location: string;
+  status: 'success' | 'failed' | 'skipped';
+  error?: string;
+}
+
+/**
+ * Parse revision history from a stored JSON string, safely.
+ * Returns an empty array on any parse failure.
+ */
+export function parseRevisionHistory(raw: unknown): RevisionEntry[] {
+  if (!raw || typeof raw !== 'string') return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (e): e is RevisionEntry =>
+        typeof e === 'object' &&
+        e !== null &&
+        typeof e.content === 'string' &&
+        typeof e.revised_at === 'string'
+    );
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Prepend a new revision entry and trim to MAX_REVISION_HISTORY.
+ */
+export function buildRevisionHistory(
+  existing: RevisionEntry[],
+  oldContent: string,
+  revisedAt: string
+): RevisionEntry[] {
+  const updated = [{ content: oldContent, revised_at: revisedAt }, ...existing];
+  return updated.slice(0, MAX_REVISION_HISTORY);
+}
+
+/**
+ * Handle remember_revise tool execution
+ *
+ * Phase 1: Validates the request and generates a confirmation token.
+ * The actual revision is executed in confirm.ts when the token is confirmed.
+ */
+export async function handleRevise(
+  args: ReviseArgs,
+  userId: string,
+  authContext?: AuthContext
+): Promise<string> {
+  const debug = createDebugLogger({
+    tool: 'remember_revise',
+    userId,
+    operation: 'revise_request',
+  });
+
+  try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+
+    logger.info('Starting revise request', {
+      tool: 'remember_revise',
+      userId,
+      memoryId: args.memory_id,
+    });
+
+    // Load source memory from user's personal collection
+    const weaviateClient = getWeaviateClient();
+    const userCollectionName = getMemoryCollectionName(userId);
+    const userCollection = weaviateClient.collections.get(userCollectionName);
+
+    const sourceMemory = await fetchMemoryWithAllProperties(
+      userCollection,
+      args.memory_id
+    );
+
+    if (!sourceMemory) {
+      logger.info('Source memory not found', {
+        tool: 'remember_revise',
+        memoryId: args.memory_id,
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Memory not found',
+          message: `Memory ${args.memory_id} does not exist`,
+        },
+        null,
+        2
+      );
+    }
+
+    // Verify ownership
+    if (sourceMemory.properties.user_id !== userId) {
+      logger.warn('Permission denied', {
+        tool: 'remember_revise',
+        memoryId: args.memory_id,
+        memoryOwner: sourceMemory.properties.user_id,
+        requestingUser: userId,
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Permission denied',
+          message: 'You can only revise your own memories',
+        },
+        null,
+        2
+      );
+    }
+
+    // Get tracking arrays
+    const spaceIds: string[] = Array.isArray(sourceMemory.properties.space_ids)
+      ? sourceMemory.properties.space_ids
+      : [];
+    const groupIds: string[] = Array.isArray(sourceMemory.properties.group_ids)
+      ? sourceMemory.properties.group_ids
+      : [];
+
+    // Validate the memory is published somewhere
+    if (spaceIds.length === 0 && groupIds.length === 0) {
+      logger.info('Memory has no published copies', {
+        tool: 'remember_revise',
+        memoryId: args.memory_id,
+      });
+      return JSON.stringify(
+        {
+          success: false,
+          error: 'Not published',
+          message:
+            'Memory has no published copies to revise. Publish first with remember_publish.',
+          context: {
+            memory_id: args.memory_id,
+            space_ids: [],
+            group_ids: [],
+          },
+        },
+        null,
+        2
+      );
+    }
+
+    // Create payload for confirmation token
+    const payload = {
+      memory_id: args.memory_id,
+      space_ids: spaceIds,
+      group_ids: groupIds,
+    };
+
+    logger.info('Generating confirmation token for revise', {
+      tool: 'remember_revise',
+      userId,
+      memoryId: args.memory_id,
+      spaceIds,
+      groupIds,
+    });
+
+    // Generate confirmation token
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      'revise_memory',
+      payload
+    );
+
+    logger.info('Confirmation token generated for revise', {
+      tool: 'remember_revise',
+      requestId,
+      token,
+      action: 'revise_memory',
+      spaceIds,
+      groupIds,
+    });
+
+    // Build destination summary for user
+    const destinations: string[] = [];
+    if (spaceIds.length > 0) {
+      destinations.push(`spaces: ${spaceIds.join(', ')}`);
+    }
+    if (groupIds.length > 0) {
+      destinations.push(`groups: ${groupIds.join(', ')}`);
+    }
+
+    return JSON.stringify(
+      {
+        success: true,
+        token,
+        message: 'Revision request created. Please confirm to sync content to all published copies.',
+        action: 'revise_memory',
+        memory_id: args.memory_id,
+        destinations: destinations.join('; '),
+        revision_details: {
+          space_ids: spaceIds,
+          group_ids: groupIds,
+          total_locations: (spaceIds.length > 0 ? 1 : 0) + groupIds.length,
+        },
+        confirmation_required: true,
+      },
+      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_revise',
+      userId,
+      operation: 'revise memory request',
+      memoryId: args.memory_id,
+    });
+  }
+}

package/src/tools/search-memory.ts

@@ -8,6 +8,9 @@ import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { buildCombinedSearchFilters, buildMemoryOnlyFilters, buildDeletedFilter, combineFiltersWithAnd } from '../utils/weaviate-filters.js';
+import { buildTrustFilter } from '../services/trust-enforcement.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
 
 /**
  * Tool definition for remember_search_memory
@@ -127,23 +130,31 @@ export const searchMemoryTool = {
  */
 export async function handleSearchMemory(
   args: SearchOptions,
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
+  const ghostMode = authContext?.ghostMode;
+  // In ghost mode, search the ghost owner's collection instead of the caller's
+  const searchUserId = ghostMode?.owner_user_id ?? userId;
+  const debug = createDebugLogger({ tool: 'remember_search_memory', userId: searchUserId, operation: ghostMode ? 'ghost search' : 'search memory' });
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args, ghostMode: !!ghostMode });
     // Validate query is not empty
     if (!args.query || args.query.trim() === '') {
       throw new Error('Query cannot be empty');
     }
 
     const includeRelationships = args.include_relationships !== false; // Default true
-    
+
     logger.info('Searching memories and relationships', {
-      userId,
+      userId: searchUserId,
       query: args.query,
-      includeRelationships
+      includeRelationships,
+      ghostMode: !!ghostMode,
     });
 
-    const collection = getMemoryCollection(userId);
+    const collection = getMemoryCollection(searchUserId);
     const alpha = args.alpha ?? 0.7;
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
@@ -151,14 +162,25 @@ export async function handleSearchMemory(
     // Build deleted filter
     const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || 'exclude');
 
+    // Build trust filter for ghost mode (resolved server-side, never from tool args)
+    const trustFilter = ghostMode
+      ? buildTrustFilter(collection, ghostMode.accessor_trust_level)
+      : null;
+
     // Build filters using v3 API
     // Use OR logic to search both memories and relationships
     const searchFilters = includeRelationships
       ? buildCombinedSearchFilters(collection, args.filters)
       : buildMemoryOnlyFilters(collection, args.filters);
 
-    // Combine deleted filter with search filters
-    const combinedFilters = combineFiltersWithAnd([deletedFilter, searchFilters].filter(f => f !== null));
+    // Exclude ghost memories by default (unless explicitly searching for them)
+    const hasExplicitTypeFilter = args.filters?.types && args.filters.types.length > 0;
+    const ghostExclusionFilter = !hasExplicitTypeFilter
+      ? collection.filter.byProperty('content_type').notEqual('ghost')
+      : null;
+
+    // Combine deleted filter, trust filter, ghost exclusion, and search filters
+    const combinedFilters = combineFiltersWithAnd([deletedFilter, trustFilter, ghostExclusionFilter, searchFilters].filter(f => f !== null));
 
     // Build search options
     const searchOptions: any = {
@@ -221,6 +243,7 @@ export async function handleSearchMemory(
 
     return JSON.stringify(searchResult, null, 2);
   } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: 'remember_search_memory',
       operation: 'search memories',

package/src/tools/search-relationship.ts

@@ -8,7 +8,9 @@ import type { Relationship, DeletedFilter } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
 import { buildDeletedFilter, combineFiltersWithAnd } from '../utils/weaviate-filters.js';
+import type { AuthContext } from '../types/auth.js';
 
 /**
  * Tool definition for remember_search_relationship
@@ -107,9 +109,15 @@ export interface SearchRelationshipResult {
  */
 export async function handleSearchRelationship(
   args: SearchRelationshipArgs,
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_search_relationship', userId, operation: 'search relationship' });
+
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+
     logger.info('Searching relationships', {
       userId,
       query: args.query,
@@ -197,7 +205,7 @@ export async function handleSearchRelationship(
       id: obj.uuid,
       user_id: obj.properties.user_id,
       doc_type: 'relationship',
-      memory_ids: obj.properties.memory_ids || [],
+      memory_ids: obj.properties.related_memory_ids || [],
       relationship_type: obj.properties.relationship_type,
       observation: obj.properties.observation,
       strength: obj.properties.strength,
@@ -228,6 +236,7 @@ export async function handleSearchRelationship(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: 'remember_search_relationship',
       operation: 'search relationships',