@prmichaelsen/remember-mcp 2.8.0 → 3.12.0

package/dist/collections/composite-ids.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Composite ID Utilities
+ *
+ * Provides utilities for working with composite IDs in Memory Collection Pattern v2.
+ * Composite IDs preserve the source reference when memories are published to spaces or groups.
+ *
+ * Format: {userId}.{memoryId}
+ * Example: "user123.my-recipe"
+ */
+/**
+ * Components of a composite ID
+ */
+export interface CompositeIdComponents {
+    userId: string;
+    memoryId: string;
+}
+/**
+ * Error thrown when composite ID is invalid
+ */
+export declare class InvalidCompositeIdError extends Error {
+    constructor(message: string);
+}
+/**
+ * Generate a composite ID from user ID and memory ID
+ *
+ * @param userId - User ID (must not contain dots)
+ * @param memoryId - Memory ID (must not contain dots)
+ * @returns Composite ID in format {userId}.{memoryId}
+ * @throws {InvalidCompositeIdError} If userId or memoryId contains dots
+ *
+ * @example
+ * generateCompositeId('user123', 'my-recipe')
+ * // Returns: 'user123.my-recipe'
+ */
+export declare function generateCompositeId(userId: string, memoryId: string): string;
+/**
+ * Parse a composite ID into its components
+ *
+ * @param compositeId - Composite ID to parse
+ * @returns Object with userId and memoryId
+ * @throws {InvalidCompositeIdError} If composite ID format is invalid
+ *
+ * @example
+ * parseCompositeId('user123.my-recipe')
+ * // Returns: { userId: 'user123', memoryId: 'my-recipe' }
+ */
+export declare function parseCompositeId(compositeId: string): CompositeIdComponents;
+/**
+ * Check if a string is a composite ID
+ *
+ * @param id - String to check
+ * @returns true if valid composite ID, false otherwise
+ *
+ * @example
+ * isCompositeId('user123.my-recipe') // true
+ * isCompositeId('simple-id') // false
+ * isCompositeId('too.many.dots') // false
+ */
+export declare function isCompositeId(id: string): boolean;
+/**
+ * Validate a composite ID (returns true on valid, throws on invalid)
+ *
+ * @param id - Composite ID to validate
+ * @returns true if valid
+ * @throws {InvalidCompositeIdError} If composite ID is invalid
+ *
+ * @example
+ * validateCompositeId('user123.my-recipe') // Returns true
+ * validateCompositeId('invalid') // Throws InvalidCompositeIdError
+ */
+export declare function validateCompositeId(id: string): true;
+/**
+ * Extract user ID from a composite ID
+ *
+ * @param compositeId - Composite ID
+ * @returns User ID component
+ *
+ * @example
+ * getUserIdFromComposite('user123.my-recipe')
+ * // Returns: 'user123'
+ */
+export declare function getUserIdFromComposite(compositeId: string): string;
+/**
+ * Extract memory ID from a composite ID
+ *
+ * @param compositeId - Composite ID
+ * @returns Memory ID component
+ *
+ * @example
+ * getMemoryIdFromComposite('user123.my-recipe')
+ * // Returns: 'my-recipe'
+ */
+export declare function getMemoryIdFromComposite(compositeId: string): string;
+/**
+ * Check if an ID belongs to a specific user
+ *
+ * @param compositeId - Composite ID to check
+ * @param userId - User ID to match
+ * @returns true if composite ID belongs to user, false otherwise
+ *
+ * @example
+ * belongsToUser('user123.my-recipe', 'user123') // true
+ * belongsToUser('user123.my-recipe', 'user456') // false
+ */
+export declare function belongsToUser(compositeId: string, userId: string): boolean;
+//# sourceMappingURL=composite-ids.d.ts.map

package/dist/collections/core-infrastructure.spec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unit tests for Memory Collection Pattern v2 Core Infrastructure
+ *
+ * Tests core functionality of:
+ * - Dot notation collection utilities
+ * - Composite ID utilities
+ * - Tracking array management
+ * - Schema definitions
+ */
+export {};
+//# sourceMappingURL=core-infrastructure.spec.d.ts.map

package/dist/collections/dot-notation.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Dot Notation Collection Utilities
+ *
+ * Provides utilities for working with Memory Collection Pattern v2's
+ * dot notation collection naming scheme.
+ *
+ * Collection Types:
+ * - USERS: Memory_users_{userId} - Private user memories
+ * - SPACES: Memory_spaces_public - All public space memories
+ * - GROUPS: Memory_groups_{groupId} - Group memories
+ */
+/**
+ * Collection type enum for Memory Collection Pattern v2
+ */
+export declare enum CollectionType {
+    USERS = "USERS",
+    SPACES = "SPACES",
+    GROUPS = "GROUPS"
+}
+/**
+ * Metadata about a parsed collection
+ */
+export interface CollectionMetadata {
+    type: CollectionType;
+    id?: string;
+    name: string;
+}
+/**
+ * Error thrown when collection name is invalid
+ */
+export declare class InvalidCollectionNameError extends Error {
+    constructor(message: string);
+}
+/**
+ * Get the Weaviate collection name for a given type and optional ID
+ *
+ * @param type - Collection type (USERS, SPACES, or GROUPS)
+ * @param id - Optional ID (required for USERS and GROUPS, not used for SPACES)
+ * @returns Weaviate collection name
+ *
+ * @example
+ * getCollectionName(CollectionType.USERS, 'user123')
+ * // Returns: 'Memory_users_user123'
+ *
+ * @example
+ * getCollectionName(CollectionType.SPACES)
+ * // Returns: 'Memory_spaces_public'
+ *
+ * @example
+ * getCollectionName(CollectionType.GROUPS, 'group456')
+ * // Returns: 'Memory_groups_group456'
+ */
+export declare function getCollectionName(type: CollectionType, id?: string): string;
+/**
+ * Parse a collection name into its components
+ *
+ * @param name - Weaviate collection name
+ * @returns Collection metadata with type, optional ID, and name
+ *
+ * @example
+ * parseCollectionName('Memory_users_user123')
+ * // Returns: { type: CollectionType.USERS, id: 'user123', name: 'Memory_users_user123' }
+ *
+ * @example
+ * parseCollectionName('Memory_spaces_public')
+ * // Returns: { type: CollectionType.SPACES, id: undefined, name: 'Memory_spaces_public' }
+ *
+ * @example
+ * parseCollectionName('Memory_groups_group456')
+ * // Returns: { type: CollectionType.GROUPS, id: 'group456', name: 'Memory_groups_group456' }
+ */
+export declare function parseCollectionName(name: string): CollectionMetadata;
+/**
+ * Validate a collection name
+ *
+ * @param name - Collection name to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * validateCollectionName('Memory_users_user123') // true
+ * validateCollectionName('Memory_spaces_public') // true
+ * validateCollectionName('Invalid_name') // false
+ */
+export declare function validateCollectionName(name: string): boolean;
+/**
+ * Check if a collection name is a user collection
+ *
+ * @param name - Collection name to check
+ * @returns true if user collection, false otherwise
+ */
+export declare function isUserCollection(name: string): boolean;
+/**
+ * Check if a collection name is the spaces collection
+ *
+ * @param name - Collection name to check
+ * @returns true if spaces collection, false otherwise
+ */
+export declare function isSpacesCollection(name: string): boolean;
+/**
+ * Check if a collection name is a group collection
+ *
+ * @param name - Collection name to check
+ * @returns true if group collection, false otherwise
+ */
+export declare function isGroupCollection(name: string): boolean;
+//# sourceMappingURL=dot-notation.d.ts.map

package/dist/collections/tracking-arrays.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Tracking Array Management
+ *
+ * Provides utilities for managing space_ids and group_ids tracking arrays
+ * in Memory Collection Pattern v2. These arrays track where memories have
+ * been published.
+ */
+/**
+ * Memory with tracking arrays
+ */
+export interface MemoryWithTracking {
+    space_ids: string[];
+    group_ids: string[];
+    [key: string]: any;
+}
+/**
+ * Published locations summary
+ */
+export interface PublishedLocations {
+    spaces: string[];
+    groups: string[];
+}
+/**
+ * Add a space ID to the space_ids array (immutable)
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param spaceId - Space ID to add
+ * @returns New memory object with updated space_ids
+ *
+ * @example
+ * const memory = { space_ids: ['cooking'], group_ids: [] }
+ * addToSpaceIds(memory, 'recipes')
+ * // Returns: { space_ids: ['cooking', 'recipes'], group_ids: [] }
+ */
+export declare function addToSpaceIds<T extends MemoryWithTracking>(memory: T, spaceId: string): T;
+/**
+ * Remove a space ID from the space_ids array (immutable)
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param spaceId - Space ID to remove
+ * @returns New memory object with updated space_ids
+ *
+ * @example
+ * const memory = { space_ids: ['cooking', 'recipes'], group_ids: [] }
+ * removeFromSpaceIds(memory, 'cooking')
+ * // Returns: { space_ids: ['recipes'], group_ids: [] }
+ */
+export declare function removeFromSpaceIds<T extends MemoryWithTracking>(memory: T, spaceId: string): T;
+/**
+ * Add a group ID to the group_ids array (immutable)
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param groupId - Group ID to add
+ * @returns New memory object with updated group_ids
+ *
+ * @example
+ * const memory = { space_ids: [], group_ids: ['family'] }
+ * addToGroupIds(memory, 'friends')
+ * // Returns: { space_ids: [], group_ids: ['family', 'friends'] }
+ */
+export declare function addToGroupIds<T extends MemoryWithTracking>(memory: T, groupId: string): T;
+/**
+ * Remove a group ID from the group_ids array (immutable)
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param groupId - Group ID to remove
+ * @returns New memory object with updated group_ids
+ *
+ * @example
+ * const memory = { space_ids: [], group_ids: ['family', 'friends'] }
+ * removeFromGroupIds(memory, 'family')
+ * // Returns: { space_ids: [], group_ids: ['friends'] }
+ */
+export declare function removeFromGroupIds<T extends MemoryWithTracking>(memory: T, groupId: string): T;
+/**
+ * Check if memory is published to a specific space
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param spaceId - Space ID to check
+ * @returns true if published to space, false otherwise
+ *
+ * @example
+ * const memory = { space_ids: ['cooking'], group_ids: [] }
+ * isPublishedToSpace(memory, 'cooking') // true
+ * isPublishedToSpace(memory, 'recipes') // false
+ */
+export declare function isPublishedToSpace(memory: MemoryWithTracking, spaceId: string): boolean;
+/**
+ * Check if memory is published to a specific group
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param groupId - Group ID to check
+ * @returns true if published to group, false otherwise
+ *
+ * @example
+ * const memory = { space_ids: [], group_ids: ['family'] }
+ * isPublishedToGroup(memory, 'family') // true
+ * isPublishedToGroup(memory, 'friends') // false
+ */
+export declare function isPublishedToGroup(memory: MemoryWithTracking, groupId: string): boolean;
+/**
+ * Get all published locations for a memory
+ *
+ * @param memory - Memory object with tracking arrays
+ * @returns Object with spaces and groups arrays
+ *
+ * @example
+ * const memory = { space_ids: ['cooking', 'recipes'], group_ids: ['family'] }
+ * getPublishedLocations(memory)
+ * // Returns: { spaces: ['cooking', 'recipes'], groups: ['family'] }
+ */
+export declare function getPublishedLocations(memory: MemoryWithTracking): PublishedLocations;
+/**
+ * Check if memory is published anywhere
+ *
+ * @param memory - Memory object with tracking arrays
+ * @returns true if published to any space or group, false otherwise
+ *
+ * @example
+ * const memory = { space_ids: ['cooking'], group_ids: [] }
+ * isPublished(memory) // true
+ *
+ * const unpublished = { space_ids: [], group_ids: [] }
+ * isPublished(unpublished) // false
+ */
+export declare function isPublished(memory: MemoryWithTracking): boolean;
+/**
+ * Get count of published locations
+ *
+ * @param memory - Memory object with tracking arrays
+ * @returns Total number of spaces and groups memory is published to
+ *
+ * @example
+ * const memory = { space_ids: ['cooking', 'recipes'], group_ids: ['family'] }
+ * getPublishedCount(memory) // 3
+ */
+export declare function getPublishedCount(memory: MemoryWithTracking): number;
+/**
+ * Initialize tracking arrays on a memory object (immutable)
+ *
+ * @param memory - Memory object (may not have tracking arrays)
+ * @returns New memory object with initialized tracking arrays
+ *
+ * @example
+ * const memory = { id: '123', content: 'test' }
+ * initializeTracking(memory)
+ * // Returns: { id: '123', content: 'test', space_ids: [], group_ids: [] }
+ */
+export declare function initializeTracking<T extends Record<string, any>>(memory: T): T & MemoryWithTracking;
+/**
+ * Add multiple space IDs at once (immutable)
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param spaceIds - Array of space IDs to add
+ * @returns New memory object with updated space_ids
+ *
+ * @example
+ * const memory = { space_ids: ['cooking'], group_ids: [] }
+ * addMultipleSpaceIds(memory, ['recipes', 'baking'])
+ * // Returns: { space_ids: ['cooking', 'recipes', 'baking'], group_ids: [] }
+ */
+export declare function addMultipleSpaceIds<T extends MemoryWithTracking>(memory: T, spaceIds: string[]): T;
+/**
+ * Add multiple group IDs at once (immutable)
+ *
+ * @param memory - Memory object with tracking arrays
+ * @param groupIds - Array of group IDs to add
+ * @returns New memory object with updated group_ids
+ *
+ * @example
+ * const memory = { space_ids: [], group_ids: ['family'] }
+ * addMultipleGroupIds(memory, ['friends', 'coworkers'])
+ * // Returns: { space_ids: [], group_ids: ['family', 'friends', 'coworkers'] }
+ */
+export declare function addMultipleGroupIds<T extends MemoryWithTracking>(memory: T, groupIds: string[]): T;
+//# sourceMappingURL=tracking-arrays.d.ts.map

package/dist/constants/content-types.d.ts

@@ -35,6 +35,7 @@ export declare const CONTENT_TYPE_CATEGORIES: {
     readonly organizational: readonly ["bookmark", "form", "location"];
     readonly business: readonly ["invoice", "contract"];
     readonly system: readonly ["system", "action", "audit", "history"];
+    readonly cross_user: readonly ["ghost", "comment"];
 };
 /**
  * Get content type metadata

package/dist/schema/v2-collections-comments.spec.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Tests for comment-related schema fields in v2 collections.
+ *
+ * Verifies that parent_id, thread_root_id, and moderation_flags
+ * are present in both user and published collection schemas.
+ */
+export {};
+//# sourceMappingURL=v2-collections-comments.spec.d.ts.map

package/dist/schema/v2-collections.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Weaviate Schema Definitions for Memory Collection Pattern v2
+ *
+ * Defines schemas for the three collection types:
+ * 1. Memory_users_{userId} - User's private memories
+ * 2. Memory_spaces_public - Shared space memories
+ * 3. Memory_groups_{groupId} - Group memories
+ */
+import { WeaviateClient } from 'weaviate-client';
+/**
+ * Create schema for a user's private memory collection
+ *
+ * @param userId - The user ID
+ * @returns Weaviate collection schema configuration
+ *
+ * @example
+ * ```typescript
+ * const schema = createUserCollectionSchema('user123')
+ * await client.collections.create(schema)
+ * ```
+ */
+export declare function createUserCollectionSchema(userId: string): {
+    name: string;
+    description: string;
+    vectorizers: import("weaviate-client").VectorConfigCreate<never, undefined, "hnsw", "text2vec-openai">;
+    properties: ({
+        name: string;
+        dataType: "text";
+    } | {
+        name: string;
+        dataType: "text[]";
+    } | {
+        name: string;
+        dataType: "date";
+    } | {
+        name: string;
+        dataType: "int";
+    } | {
+        name: string;
+        dataType: "number";
+    })[];
+    invertedIndex: {
+        bm25?: {
+            k1?: number | undefined;
+            b?: number | undefined;
+        } | undefined;
+        cleanupIntervalSeconds?: number | undefined;
+        indexTimestamps?: boolean | undefined;
+        indexPropertyLength?: boolean | undefined;
+        indexNullState?: boolean | undefined;
+        stopwords?: {
+            preset?: string | undefined;
+            additions?: (string | undefined)[] | undefined;
+            removals?: (string | undefined)[] | undefined;
+        } | undefined;
+    };
+};
+/**
+ * Create schema for the shared spaces collection
+ *
+ * @returns Weaviate collection schema configuration
+ *
+ * @example
+ * ```typescript
+ * const schema = createSpaceCollectionSchema()
+ * await client.collections.create(schema)
+ * ```
+ */
+export declare function createSpaceCollectionSchema(): {
+    name: string;
+    description: string;
+    vectorizers: import("weaviate-client").VectorConfigCreate<never, undefined, "hnsw", "text2vec-openai">;
+    properties: ({
+        name: string;
+        dataType: "text";
+    } | {
+        name: string;
+        dataType: "text[]";
+    } | {
+        name: string;
+        dataType: "date";
+    } | {
+        name: string;
+        dataType: "int";
+    } | {
+        name: string;
+        dataType: "number";
+    })[];
+    invertedIndex: {
+        bm25?: {
+            k1?: number | undefined;
+            b?: number | undefined;
+        } | undefined;
+        cleanupIntervalSeconds?: number | undefined;
+        indexTimestamps?: boolean | undefined;
+        indexPropertyLength?: boolean | undefined;
+        indexNullState?: boolean | undefined;
+        stopwords?: {
+            preset?: string | undefined;
+            additions?: (string | undefined)[] | undefined;
+            removals?: (string | undefined)[] | undefined;
+        } | undefined;
+    };
+};
+/**
+ * Create schema for a group memory collection
+ *
+ * @param groupId - The group ID
+ * @returns Weaviate collection schema configuration
+ *
+ * @example
+ * ```typescript
+ * const schema = createGroupCollectionSchema('group456')
+ * await client.collections.create(schema)
+ * ```
+ */
+export declare function createGroupCollectionSchema(groupId: string): {
+    name: string;
+    description: string;
+    vectorizers: import("weaviate-client").VectorConfigCreate<never, undefined, "hnsw", "text2vec-openai">;
+    properties: ({
+        name: string;
+        dataType: "text";
+    } | {
+        name: string;
+        dataType: "text[]";
+    } | {
+        name: string;
+        dataType: "date";
+    } | {
+        name: string;
+        dataType: "int";
+    } | {
+        name: string;
+        dataType: "number";
+    })[];
+    invertedIndex: {
+        bm25?: {
+            k1?: number | undefined;
+            b?: number | undefined;
+        } | undefined;
+        cleanupIntervalSeconds?: number | undefined;
+        indexTimestamps?: boolean | undefined;
+        indexPropertyLength?: boolean | undefined;
+        indexNullState?: boolean | undefined;
+        stopwords?: {
+            preset?: string | undefined;
+            additions?: (string | undefined)[] | undefined;
+            removals?: (string | undefined)[] | undefined;
+        } | undefined;
+    };
+};
+/**
+ * Ensure a user collection exists (create if needed)
+ *
+ * @param client - Weaviate client
+ * @param userId - The user ID
+ * @returns True if collection was created, false if it already existed
+ */
+export declare function ensureUserCollection(client: WeaviateClient, userId: string): Promise<boolean>;
+/**
+ * Ensure the spaces collection exists (create if needed)
+ *
+ * @param client - Weaviate client
+ * @returns True if collection was created, false if it already existed
+ */
+export declare function ensureSpaceCollection(client: WeaviateClient): Promise<boolean>;
+/**
+ * Ensure a group collection exists (create if needed)
+ *
+ * @param client - Weaviate client
+ * @param groupId - The group ID
+ * @returns True if collection was created, false if it already existed
+ */
+export declare function ensureGroupCollection(client: WeaviateClient, groupId: string): Promise<boolean>;
+/**
+ * Get all property names for user collections
+ *
+ * @returns Array of property names
+ */
+export declare function getUserCollectionProperties(): string[];
+/**
+ * Get all property names for space/group collections
+ *
+ * @returns Array of property names
+ */
+export declare function getPublishedCollectionProperties(): string[];
+/**
+ * Validate that a collection name matches the expected v2 pattern
+ *
+ * @param collectionName - The collection name to validate
+ * @returns True if valid
+ * @throws Error if invalid
+ */
+export declare function validateV2CollectionName(collectionName: string): boolean;
+/**
+ * Get the collection type from a collection name
+ *
+ * @param collectionName - The collection name
+ * @returns 'users', 'spaces', or 'groups'
+ */
+export declare function getCollectionType(collectionName: string): 'users' | 'spaces' | 'groups';
+/**
+ * Extract the ID from a user or group collection name
+ *
+ * @param collectionName - The collection name
+ * @returns The user ID or group ID
+ */
+export declare function extractIdFromCollectionName(collectionName: string): string | null;
+//# sourceMappingURL=v2-collections.d.ts.map

package/dist/server-factory.d.ts

@@ -6,6 +6,21 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 export interface ServerOptions {
     name?: string;
     version?: string;
+    /**
+     * Ghost mode configuration. When set, the server operates in ghost mode:
+     * - Search/query tools search the ghost owner's collection
+     * - Trust filtering is applied based on the accessor's trust level
+     * - Trust level is resolved server-side from GhostConfig (Firestore)
+     *
+     * agentbase.me sets this when creating a ghost conversation server.
+     * The LLM never has access to set or override these values.
+     */
+    ghostMode?: {
+        /** Ghost owner's user ID (whose memories to search) */
+        owner_user_id: string;
+        /** Accessor's user ID (who is chatting with the ghost) */
+        accessor_user_id: string;
+    };
 }
 /**
  * Create a server instance for a specific user/tenant