@prmichaelsen/remember-mcp 2.2.1 → 2.3.0

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,167 @@
+/**
+ * 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 {
+    // Validate space ID
+    if (!isValidSpaceId(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 userCollection = weaviateClient.collections.get(
+      getMemoryCollectionName(userId)
+    );
+
+    const memory = await userCollection.query.fetchObjectById(args.memory_id);
+
+    if (!memory) {
+      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 || [],
+    };
+
+    // Generate confirmation token
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      'publish_memory',
+      payload,
+      args.target
+    );
+
+    // 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,
+    });
+  }
+}

package/src/tools/search-space.ts

@@ -0,0 +1,189 @@
+/**
+ * remember_search_space tool
+ * 
+ * Search shared spaces to discover memories from other users.
+ * Similar to remember_search_memory but searches 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';
+import type { SearchFilters } from '../types/memory.js';
+
+/**
+ * Tool definition for remember_search_space
+ */
+export const searchSpaceTool: Tool = {
+  name: 'remember_search_space',
+  description: 'Search shared spaces to discover thoughts, ideas, and memories. Works like remember_search_memory but searches shared spaces instead of personal memories.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Search query (semantic + keyword hybrid)',
+      },
+      space: {
+        type: 'string',
+        description: 'Which space to search',
+        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 (must have all specified tags)',
+      },
+      min_weight: {
+        type: 'number',
+        minimum: 0,
+        maximum: 1,
+        description: 'Minimum weight/significance (0-1)',
+      },
+      max_weight: {
+        type: 'number',
+        minimum: 0,
+        maximum: 1,
+        description: 'Maximum 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',
+      },
+      offset: {
+        type: 'number',
+        default: 0,
+        description: 'Offset for pagination',
+      },
+    },
+    required: ['query', 'space'],
+  },
+};
+
+interface SearchSpaceArgs {
+  query: string;
+  space: string;
+  content_type?: string;
+  tags?: string[];
+  min_weight?: number;
+  max_weight?: number;
+  date_from?: string;
+  date_to?: string;
+  limit?: number;
+  offset?: number;
+}
+
+/**
+ * Handle remember_search_space tool execution
+ */
+export async function handleSearchSpace(
+  args: SearchSpaceArgs,
+  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 for space search
+    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 filters
+    if (args.min_weight !== undefined) {
+      filterList.push(spaceCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
+    }
+
+    if (args.max_weight !== undefined) {
+      filterList.push(spaceCollection.filter.byProperty('weight').lessOrEqual(args.max_weight));
+    }
+
+    // Apply date filters (convert ISO strings to Date objects)
+    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 hybrid search
+    const searchResults = await spaceCollection.query.hybrid(args.query, {
+      limit: args.limit || 10,
+      offset: args.offset || 0,
+      ...(whereFilter && { where: whereFilter }),
+    });
+
+    // Format results
+    const memories = searchResults.objects.map((obj) => ({
+      id: obj.uuid,
+      ...obj.properties,
+      _score: obj.metadata?.score,
+    }));
+
+    const result = {
+      space: args.space,
+      query: args.query,
+      memories,
+      total: memories.length,
+      offset: args.offset || 0,
+      limit: args.limit || 10,
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    handleToolError(error, {
+      toolName: 'remember_search_space',
+      operation: 'search space',
+      space: args.space,
+      query: args.query,
+    });
+  }
+}

package/src/types/space-memory.ts

@@ -0,0 +1,94 @@
+/**
+ * Space Memory type definitions for remember-mcp
+ * 
+ * Space memories are memories published to shared collections
+ * where they can be discovered by other users.
+ */
+
+import type { Memory, SearchOptions, SearchResult } from './memory.js';
+
+/**
+ * Space memory - a memory published to a shared space
+ * 
+ * Extends Memory with additional fields for attribution and discovery
+ */
+export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
+  /**
+   * Space identifier (snake_case)
+   * Examples: 'the_void', 'public_space'
+   */
+  space_id: string;
+
+  /**
+   * Original author's user_id (for permissions)
+   * This is private and not shown publicly
+   */
+  author_id: string;
+
+  /**
+   * Optional ghost profile ID for pseudonymous publishing
+   * If present, memory is attributed to ghost instead of user
+   */
+  ghost_id?: string;
+
+  /**
+   * When the memory was published to the space
+   */
+  published_at: string;
+
+  /**
+   * How many times this memory has been discovered/viewed
+   */
+  discovery_count: number;
+
+  /**
+   * Attribution type
+   * - 'user': Published as the user (shows author_id)
+   * - 'ghost': Published as a ghost (shows ghost_id)
+   */
+  attribution: 'user' | 'ghost';
+
+  /**
+   * Document type discriminator
+   * Always 'space_memory' for space memories
+   */
+  doc_type: 'space_memory';
+}
+
+/**
+ * Search options for space memories
+ * Same as SearchOptions but for space collections
+ */
+export interface SpaceSearchOptions extends Omit<SearchOptions, 'include_relationships'> {
+  /**
+   * Space to search
+   */
+  space: string;
+}
+
+/**
+ * Search result for space memories
+ */
+export interface SpaceSearchResult extends Omit<SearchResult, 'memories' | 'relationships'> {
+  /**
+   * Found space memories
+   */
+  space_memories: SpaceMemory[];
+}
+
+/**
+ * Supported space IDs
+ */
+export type SpaceId = 'the_void';
+
+/**
+ * Space display names mapped to IDs
+ */
+export const SPACE_DISPLAY_NAMES: Record<SpaceId, string> = {
+  the_void: 'The Void',
+};
+
+/**
+ * Supported spaces constant
+ */
+export const SUPPORTED_SPACES: SpaceId[] = ['the_void'];