@prmichaelsen/remember-mcp 3.13.0 → 3.14.0

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

@@ -1,176 +0,0 @@
-/**
- * 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

@@ -1,61 +0,0 @@
-/**
- * Content type constants and descriptions
- * Based on agent/design/content-types-expansion.md and default-template-library.md
- */
-import type { ContentType } from '../types/memory.js';
-/**
- * All available content types
- */
-export declare const CONTENT_TYPES: readonly ContentType[];
-/**
- * Content type metadata
- */
-export interface ContentTypeMetadata {
-    name: ContentType;
-    category: string;
-    description: string;
-    examples: string[];
-    common_fields?: string[];
-}
-/**
- * Comprehensive content type descriptions
- */
-export declare const CONTENT_TYPE_METADATA: Record<ContentType, ContentTypeMetadata>;
-/**
- * Content type categories
- */
-export declare const CONTENT_TYPE_CATEGORIES: {
-    readonly core: readonly ["code", "note", "documentation", "reference"];
-    readonly task: readonly ["todo", "checklist", "project", "goal", "habit"];
-    readonly communication: readonly ["email", "conversation", "meeting", "person"];
-    readonly content: readonly ["article", "webpage", "social", "presentation", "spreadsheet", "pdf"];
-    readonly media: readonly ["image", "video", "audio", "transcript"];
-    readonly creative: readonly ["song", "screenplay", "recipe", "idea", "quote", "poetry"];
-    readonly personal: readonly ["journal", "memory", "event"];
-    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
- */
-export declare function getContentTypeMetadata(type: ContentType): ContentTypeMetadata;
-/**
- * Get content types by category
- */
-export declare function getContentTypesByCategory(category: keyof typeof CONTENT_TYPE_CATEGORIES): ContentType[];
-/**
- * Validate content type
- */
-export declare function isValidContentType(type: string): type is ContentType;
-/**
- * Get content type description for LLM prompts
- * Generated dynamically from CONTENT_TYPE_METADATA
- */
-export declare function getContentTypeDescription(): string;
-/**
- * Default content type
- */
-export declare const DEFAULT_CONTENT_TYPE: ContentType;
-//# sourceMappingURL=content-types.d.ts.map

package/dist/services/confirmation-token.service.d.ts

@@ -1,99 +0,0 @@
-/**
- * Confirmation Token Service
- *
- * Manages confirmation tokens for sensitive operations like publishing memories.
- * Tokens are one-time use with 5-minute expiry.
- */
-/**
- * Confirmation request stored in Firestore
- */
-export interface ConfirmationRequest {
-    user_id: string;
-    token: string;
-    action: string;
-    target_collection?: string;
-    payload: any;
-    created_at: string;
-    expires_at: string;
-    status: 'pending' | 'confirmed' | 'denied' | 'expired' | 'retracted';
-    confirmed_at?: string;
-}
-/**
- * Service for managing confirmation tokens
- */
-export declare class ConfirmationTokenService {
-    private readonly EXPIRY_MINUTES;
-    /**
-     * Create a new confirmation request
-     *
-     * @param userId - User ID who initiated the request
-     * @param action - Action type (e.g., 'publish_memory')
-     * @param payload - Data to store with the request
-     * @param targetCollection - Optional target collection (e.g., 'the_void')
-     * @returns Request ID and token
-     */
-    createRequest(userId: string, action: string, payload: any, targetCollection?: string): Promise<{
-        requestId: string;
-        token: string;
-    }>;
-    /**
-     * Validate and retrieve a confirmation request
-     *
-     * @param userId - User ID
-     * @param token - Confirmation token
-     * @returns Request with request_id if valid, null otherwise
-     */
-    validateToken(userId: string, token: string): Promise<(ConfirmationRequest & {
-        request_id: string;
-    }) | null>;
-    /**
-     * Confirm a request
-     *
-     * @param userId - User ID
-     * @param token - Confirmation token
-     * @returns Confirmed request if valid, null otherwise
-     */
-    confirmRequest(userId: string, token: string): Promise<(ConfirmationRequest & {
-        request_id: string;
-    }) | null>;
-    /**
-     * Deny a request
-     *
-     * @param userId - User ID
-     * @param token - Confirmation token
-     * @returns True if denied successfully, false otherwise
-     */
-    denyRequest(userId: string, token: string): Promise<boolean>;
-    /**
-     * Retract a request
-     *
-     * @param userId - User ID
-     * @param token - Confirmation token
-     * @returns True if retracted successfully, false otherwise
-     */
-    retractRequest(userId: string, token: string): Promise<boolean>;
-    /**
-     * Update request status
-     *
-     * @param userId - User ID
-     * @param requestId - Request document ID
-     * @param status - New status
-     */
-    private updateStatus;
-    /**
-     * Clean up expired requests (optional - Firestore TTL handles deletion)
-     *
-     * Note: Configure Firestore TTL policy on 'requests' collection group
-     * with 'expires_at' field for automatic deletion within 24 hours.
-     *
-     * This method is optional for immediate cleanup if needed.
-     *
-     * @returns Count of deleted requests
-     */
-    cleanupExpired(): Promise<number>;
-}
-/**
- * Singleton instance of the confirmation token service
- */
-export declare const confirmationTokenService: ConfirmationTokenService;
-//# sourceMappingURL=confirmation-token.service.d.ts.map

package/dist/services/confirmation-token.service.spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for Confirmation Token Service
- */
-export {};
-//# sourceMappingURL=confirmation-token.service.spec.d.ts.map

package/dist/services/preferences-database.service.d.ts

@@ -1,22 +0,0 @@
-/**
- * Preferences Database Service
- * Handles all Firestore operations for user preferences
- */
-import { UserPreferences } from '../types/preferences.js';
-export declare class PreferencesDatabaseService {
-    /**
-     * Get user preferences
-     * Returns defaults if preferences don't exist
-     */
-    static getPreferences(userId: string): Promise<UserPreferences>;
-    /**
-     * Update user preferences (partial update with merge)
-     * Creates with defaults if preferences don't exist
-     */
-    static updatePreferences(userId: string, updates: Partial<Omit<UserPreferences, 'user_id' | 'created_at'>>): Promise<UserPreferences>;
-    /**
-     * Create preferences with defaults
-     */
-    static createPreferences(userId: string): Promise<UserPreferences>;
-}
-//# sourceMappingURL=preferences-database.service.d.ts.map

package/dist/services/space-config.service.d.ts

@@ -1,23 +0,0 @@
-/**
- * Space/Group Configuration Service
- *
- * Per-space and per-group behavioral configuration stored in Firestore.
- * Controls moderation requirements, write modes, and other behavioral rules.
- */
-import type { WriteMode } from '../types/auth.js';
-export interface SpaceConfig {
-    require_moderation: boolean;
-    default_write_mode: WriteMode;
-}
-export declare const DEFAULT_SPACE_CONFIG: SpaceConfig;
-/**
- * Get configuration for a space or group.
- * Returns defaults merged with any stored config.
- */
-export declare function getSpaceConfig(id: string, type: 'space' | 'group'): Promise<SpaceConfig>;
-/**
- * Set configuration for a space or group.
- * Merges partial config with existing values.
- */
-export declare function setSpaceConfig(id: string, type: 'space' | 'group', config: Partial<SpaceConfig>): Promise<void>;
-//# sourceMappingURL=space-config.service.d.ts.map

package/dist/services/space-config.service.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=space-config.service.spec.d.ts.map

package/src/collections/composite-ids.ts

@@ -1,193 +0,0 @@
-/**
- * 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 class InvalidCompositeIdError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidCompositeIdError'
-  }
-}
-
-/**
- * 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 function generateCompositeId(userId: string, memoryId: string): string {
-  // Validate that neither component contains dots
-  if (userId.includes('.')) {
-    throw new InvalidCompositeIdError(
-      `User ID cannot contain dots: ${userId}`
-    )
-  }
-  
-  if (memoryId.includes('.')) {
-    throw new InvalidCompositeIdError(
-      `Memory ID cannot contain dots: ${memoryId}`
-    )
-  }
-  
-  // Validate that components are not empty
-  if (!userId.trim()) {
-    throw new InvalidCompositeIdError('User ID cannot be empty')
-  }
-  
-  if (!memoryId.trim()) {
-    throw new InvalidCompositeIdError('Memory ID cannot be empty')
-  }
-  
-  return `${userId}.${memoryId}`
-}
-
-/**
- * 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 function parseCompositeId(compositeId: string): CompositeIdComponents {
-  // Split on first dot only (in case memoryId was generated with dashes that look like dots)
-  const parts = compositeId.split('.')
-  
-  if (parts.length !== 2) {
-    throw new InvalidCompositeIdError(
-      `Invalid composite ID format: ${compositeId}. Composite ID must be exactly 2 parts separated by a dot. Expected format: {userId}.{memoryId}`
-    )
-  }
-  
-  const [userId, memoryId] = parts
-  
-  // Validate components are not empty
-  if (!userId.trim()) {
-    throw new InvalidCompositeIdError(
-      `Invalid composite ID: ${compositeId}. User ID is empty`
-    )
-  }
-  
-  if (!memoryId.trim()) {
-    throw new InvalidCompositeIdError(
-      `Invalid composite ID: ${compositeId}. Memory ID is empty`
-    )
-  }
-  
-  return { userId, memoryId }
-}
-
-/**
- * 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 function isCompositeId(id: string): boolean {
-  try {
-    parseCompositeId(id)
-    return true
-  } catch (error) {
-    if (error instanceof InvalidCompositeIdError) {
-      return false
-    }
-    throw error
-  }
-}
-
-/**
- * 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 function validateCompositeId(id: string): true {
-  parseCompositeId(id) // Will throw if invalid
-  return true
-}
-
-/**
- * Extract user ID from a composite ID
- * 
- * @param compositeId - Composite ID
- * @returns User ID component
- * 
- * @example
- * getUserIdFromComposite('user123.my-recipe')
- * // Returns: 'user123'
- */
-export function getUserIdFromComposite(compositeId: string): string {
-  const { userId } = parseCompositeId(compositeId)
-  return userId
-}
-
-/**
- * Extract memory ID from a composite ID
- * 
- * @param compositeId - Composite ID
- * @returns Memory ID component
- * 
- * @example
- * getMemoryIdFromComposite('user123.my-recipe')
- * // Returns: 'my-recipe'
- */
-export function getMemoryIdFromComposite(compositeId: string): string {
-  const { memoryId } = parseCompositeId(compositeId)
-  return memoryId
-}
-
-/**
- * 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 function belongsToUser(compositeId: string, userId: string): boolean {
-  try {
-    const { userId: idUserId } = parseCompositeId(compositeId)
-    return idUserId === userId
-  } catch {
-    return false
-  }
-}