@dollhousemcp/mcp-server 1.8.0 → 1.9.0

package/dist/elements/memories/constants.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Constants for Memory element implementation
+ * Extracted for reusability and maintainability
+ *
+ * MEMORY ARCHITECTURE DESIGN:
+ * - Memories are stored as small, sharded YAML files for fast loading
+ * - Each memory file should be <256KB for optimal parse performance
+ * - Larger content referenced via external documents (PDFs, images, etc)
+ * - Index-of-indexes pattern for O(log n) search performance
+ *
+ * SECURITY NOTE: This file contains only constants and type definitions.
+ * It does not process any user input. The security scanner may flag this
+ * for missing Unicode normalization, but this is a false positive as no
+ * input processing occurs here.
+ *
+ * @module MemoryConstants
+ */
+export declare const MEMORY_CONSTANTS: {
+    readonly MAX_MEMORY_SIZE: number;
+    readonly MAX_ENTRY_SIZE: number;
+    readonly MAX_ENTRIES_DEFAULT: 1000;
+    readonly MAX_TAGS_PER_ENTRY: 20;
+    readonly MAX_TAG_LENGTH: 50;
+    readonly MAX_METADATA_KEYS: 20;
+    readonly MAX_METADATA_KEY_LENGTH: 50;
+    readonly MAX_METADATA_VALUE_LENGTH: 200;
+    readonly DEFAULT_RETENTION_DAYS: 30;
+    readonly MIN_RETENTION_DAYS: 1;
+    readonly MAX_RETENTION_DAYS: 365;
+    readonly DEFAULT_SEARCH_LIMIT: 100;
+    /**
+     * YAML Size Limit Rationale:
+     * 256KB is optimal for YAML parsing performance while preventing DoS attacks.
+     * - YAML parsing is CPU-intensive; large files can block the event loop
+     * - 256KB accommodates ~5000 lines of typical memory content
+     * - Larger memories should be sharded across multiple files
+     * - External references used for binary data (images, PDFs, etc)
+     *
+     * Performance benchmarks:
+     * - <256KB: Parse time <10ms on average hardware
+     * - 1MB: Parse time ~50-100ms (acceptable but not ideal)
+     * - >5MB: Parse time >500ms (unacceptable, blocks UI)
+     */
+    readonly MAX_YAML_SIZE: number;
+    /**
+     * Privacy Level Hierarchy:
+     *
+     * 'public' - Lowest restriction level
+     *   - Available to all contexts and users
+     *   - Can be shared across sessions
+     *   - Suitable for general knowledge, documentation
+     *   - Example: Project conventions, public APIs
+     *
+     * 'private' - Default level, moderate restriction
+     *   - Restricted to current user/session
+     *   - Not shared with other users
+     *   - Suitable for personal preferences, user-specific data
+     *   - Example: User's coding style, personal notes
+     *
+     * 'sensitive' - Highest restriction level
+     *   - Requires explicit permission to access
+     *   - Extra logging and audit trail
+     *   - Automatic deletion after retention period
+     *   - Suitable for credentials, PII, confidential data
+     *   - Example: API keys (temporary), personal information
+     *
+     * Access rules cascade: sensitive ⊂ private ⊂ public
+     */
+    readonly PRIVACY_LEVELS: readonly ["public", "private", "sensitive"];
+    readonly DEFAULT_PRIVACY_LEVEL: "private";
+    readonly DEFAULT_STORAGE_BACKEND: "memory";
+    readonly SUPPORTED_STORAGE_BACKENDS: readonly ["memory", "file", "indexed"];
+};
+export type PrivacyLevel = typeof MEMORY_CONSTANTS.PRIVACY_LEVELS[number];
+export type StorageBackend = typeof MEMORY_CONSTANTS.SUPPORTED_STORAGE_BACKENDS[number];
+export declare const MEMORY_SECURITY_EVENTS: {
+    readonly MEMORY_CREATED: "MEMORY_CREATED";
+    readonly MEMORY_ADDED: "MEMORY_ADDED";
+    readonly MEMORY_SEARCHED: "MEMORY_SEARCHED";
+    readonly SENSITIVE_MEMORY_DELETED: "SENSITIVE_MEMORY_DELETED";
+    readonly RETENTION_POLICY_ENFORCED: "RETENTION_POLICY_ENFORCED";
+    readonly MEMORY_CLEARED: "MEMORY_CLEARED";
+    readonly MEMORY_LOADED: "MEMORY_LOADED";
+    readonly MEMORY_SAVED: "MEMORY_SAVED";
+    readonly MEMORY_DELETED: "MEMORY_DELETED";
+    readonly MEMORY_LOAD_FAILED: "MEMORY_LOAD_FAILED";
+    readonly MEMORY_SAVE_FAILED: "MEMORY_SAVE_FAILED";
+    readonly MEMORY_DESERIALIZE_FAILED: "MEMORY_DESERIALIZE_FAILED";
+    readonly MEMORY_LIST_ITEM_FAILED: "MEMORY_LIST_ITEM_FAILED";
+    readonly MEMORY_IMPORT_FAILED: "MEMORY_IMPORT_FAILED";
+    readonly MEMORY_INTEGRITY_VIOLATION: "MEMORY_INTEGRITY_VIOLATION";
+    readonly MEMORY_UNICODE_VALIDATION_FAILED: "MEMORY_UNICODE_VALIDATION_FAILED";
+    readonly MEMORY_DUPLICATE_DETECTED: "MEMORY_DUPLICATE_DETECTED";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/elements/memories/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/elements/memories/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;IAqB3B;;;;;;;;;;;;OAYG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;;;;CAOK,CAAC;AAGX,MAAM,MAAM,YAAY,GAAG,OAAO,gBAAgB,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;AAC1E,MAAM,MAAM,cAAc,GAAG,OAAO,gBAAgB,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC;AAGxF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;CAkBzB,CAAC"}

package/dist/elements/memories/constants.js

@@ -0,0 +1,102 @@
+/**
+ * Constants for Memory element implementation
+ * Extracted for reusability and maintainability
+ *
+ * MEMORY ARCHITECTURE DESIGN:
+ * - Memories are stored as small, sharded YAML files for fast loading
+ * - Each memory file should be <256KB for optimal parse performance
+ * - Larger content referenced via external documents (PDFs, images, etc)
+ * - Index-of-indexes pattern for O(log n) search performance
+ *
+ * SECURITY NOTE: This file contains only constants and type definitions.
+ * It does not process any user input. The security scanner may flag this
+ * for missing Unicode normalization, but this is a false positive as no
+ * input processing occurs here.
+ *
+ * @module MemoryConstants
+ */
+// security-audit-ignore: DMCP-SEC-004
+// Reason: Constants file - no user input processing
+// Memory size limits
+export const MEMORY_CONSTANTS = {
+    // Size limits
+    MAX_MEMORY_SIZE: 1024 * 1024, // 1MB total memory size
+    MAX_ENTRY_SIZE: 100 * 1024, // 100KB per entry
+    MAX_ENTRIES_DEFAULT: 1000, // Maximum number of entries
+    // Entry limits
+    MAX_TAGS_PER_ENTRY: 20, // Maximum tags per memory entry
+    MAX_TAG_LENGTH: 50, // Maximum length of each tag
+    MAX_METADATA_KEYS: 20, // Maximum metadata keys per entry
+    MAX_METADATA_KEY_LENGTH: 50, // Maximum metadata key length
+    MAX_METADATA_VALUE_LENGTH: 200, // Maximum metadata value length
+    // Retention defaults
+    DEFAULT_RETENTION_DAYS: 30, // Default retention period
+    MIN_RETENTION_DAYS: 1, // Minimum retention period
+    MAX_RETENTION_DAYS: 365, // Maximum retention period
+    // Search limits
+    DEFAULT_SEARCH_LIMIT: 100, // Default search result limit
+    /**
+     * YAML Size Limit Rationale:
+     * 256KB is optimal for YAML parsing performance while preventing DoS attacks.
+     * - YAML parsing is CPU-intensive; large files can block the event loop
+     * - 256KB accommodates ~5000 lines of typical memory content
+     * - Larger memories should be sharded across multiple files
+     * - External references used for binary data (images, PDFs, etc)
+     *
+     * Performance benchmarks:
+     * - <256KB: Parse time <10ms on average hardware
+     * - 1MB: Parse time ~50-100ms (acceptable but not ideal)
+     * - >5MB: Parse time >500ms (unacceptable, blocks UI)
+     */
+    MAX_YAML_SIZE: 256 * 1024, // 256KB max YAML size for import
+    /**
+     * Privacy Level Hierarchy:
+     *
+     * 'public' - Lowest restriction level
+     *   - Available to all contexts and users
+     *   - Can be shared across sessions
+     *   - Suitable for general knowledge, documentation
+     *   - Example: Project conventions, public APIs
+     *
+     * 'private' - Default level, moderate restriction
+     *   - Restricted to current user/session
+     *   - Not shared with other users
+     *   - Suitable for personal preferences, user-specific data
+     *   - Example: User's coding style, personal notes
+     *
+     * 'sensitive' - Highest restriction level
+     *   - Requires explicit permission to access
+     *   - Extra logging and audit trail
+     *   - Automatic deletion after retention period
+     *   - Suitable for credentials, PII, confidential data
+     *   - Example: API keys (temporary), personal information
+     *
+     * Access rules cascade: sensitive ⊂ private ⊂ public
+     */
+    PRIVACY_LEVELS: ['public', 'private', 'sensitive'],
+    DEFAULT_PRIVACY_LEVEL: 'private',
+    // Storage backends
+    DEFAULT_STORAGE_BACKEND: 'memory',
+    SUPPORTED_STORAGE_BACKENDS: ['memory', 'file', 'indexed'],
+};
+// Security event types for memory operations
+export const MEMORY_SECURITY_EVENTS = {
+    MEMORY_CREATED: 'MEMORY_CREATED',
+    MEMORY_ADDED: 'MEMORY_ADDED',
+    MEMORY_SEARCHED: 'MEMORY_SEARCHED',
+    SENSITIVE_MEMORY_DELETED: 'SENSITIVE_MEMORY_DELETED',
+    RETENTION_POLICY_ENFORCED: 'RETENTION_POLICY_ENFORCED',
+    MEMORY_CLEARED: 'MEMORY_CLEARED',
+    MEMORY_LOADED: 'MEMORY_LOADED',
+    MEMORY_SAVED: 'MEMORY_SAVED',
+    MEMORY_DELETED: 'MEMORY_DELETED',
+    MEMORY_LOAD_FAILED: 'MEMORY_LOAD_FAILED',
+    MEMORY_SAVE_FAILED: 'MEMORY_SAVE_FAILED',
+    MEMORY_DESERIALIZE_FAILED: 'MEMORY_DESERIALIZE_FAILED',
+    MEMORY_LIST_ITEM_FAILED: 'MEMORY_LIST_ITEM_FAILED',
+    MEMORY_IMPORT_FAILED: 'MEMORY_IMPORT_FAILED',
+    MEMORY_INTEGRITY_VIOLATION: 'MEMORY_INTEGRITY_VIOLATION',
+    MEMORY_UNICODE_VALIDATION_FAILED: 'MEMORY_UNICODE_VALIDATION_FAILED',
+    MEMORY_DUPLICATE_DETECTED: 'MEMORY_DUPLICATE_DETECTED',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/elements/memories/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,sCAAsC;AACtC,oDAAoD;AAEpD,qBAAqB;AACrB,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,cAAc;IACd,eAAe,EAAE,IAAI,GAAG,IAAI,EAAS,wBAAwB;IAC7D,cAAc,EAAE,GAAG,GAAG,IAAI,EAAW,kBAAkB;IACvD,mBAAmB,EAAE,IAAI,EAAY,4BAA4B;IAEjE,eAAe;IACf,kBAAkB,EAAE,EAAE,EAAe,gCAAgC;IACrE,cAAc,EAAE,EAAE,EAAmB,6BAA6B;IAClE,iBAAiB,EAAE,EAAE,EAAgB,kCAAkC;IACvE,uBAAuB,EAAE,EAAE,EAAU,8BAA8B;IACnE,yBAAyB,EAAE,GAAG,EAAO,gCAAgC;IAErE,qBAAqB;IACrB,sBAAsB,EAAE,EAAE,EAAW,2BAA2B;IAChE,kBAAkB,EAAE,CAAC,EAAgB,2BAA2B;IAChE,kBAAkB,EAAE,GAAG,EAAc,2BAA2B;IAEhE,gBAAgB;IAChB,oBAAoB,EAAE,GAAG,EAAY,8BAA8B;IAEnE;;;;;;;;;;;;OAYG;IACH,aAAa,EAAE,GAAG,GAAG,IAAI,EAAY,iCAAiC;IAEtE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cAAc,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,WAAW,CAAU;IAC3D,qBAAqB,EAAE,SAAkB;IAEzC,mBAAmB;IACnB,uBAAuB,EAAE,QAAiB;IAC1C,0BAA0B,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAU;CAC1D,CAAC;AAMX,6CAA6C;AAC7C,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,cAAc,EAAE,gBAAgB;IAChC,YAAY,EAAE,cAAc;IAC5B,eAAe,EAAE,iBAAiB;IAClC,wBAAwB,EAAE,0BAA0B;IACpD,yBAAyB,EAAE,2BAA2B;IACtD,cAAc,EAAE,gBAAgB;IAChC,aAAa,EAAE,eAAe;IAC9B,YAAY,EAAE,cAAc;IAC5B,cAAc,EAAE,gBAAgB;IAChC,kBAAkB,EAAE,oBAAoB;IACxC,kBAAkB,EAAE,oBAAoB;IACxC,yBAAyB,EAAE,2BAA2B;IACtD,uBAAuB,EAAE,yBAAyB;IAClD,oBAAoB,EAAE,sBAAsB;IAC5C,0BAA0B,EAAE,4BAA4B;IACxD,gCAAgC,EAAE,kCAAkC;IACpE,yBAAyB,EAAE,2BAA2B;CAC9C,CAAC","sourcesContent":["/**\n * Constants for Memory element implementation\n * Extracted for reusability and maintainability\n *\n * MEMORY ARCHITECTURE DESIGN:\n * - Memories are stored as small, sharded YAML files for fast loading\n * - Each memory file should be <256KB for optimal parse performance\n * - Larger content referenced via external documents (PDFs, images, etc)\n * - Index-of-indexes pattern for O(log n) search performance\n *\n * SECURITY NOTE: This file contains only constants and type definitions.\n * It does not process any user input. The security scanner may flag this\n * for missing Unicode normalization, but this is a false positive as no\n * input processing occurs here.\n *\n * @module MemoryConstants\n */\n\n// security-audit-ignore: DMCP-SEC-004\n// Reason: Constants file - no user input processing\n\n// Memory size limits\nexport const MEMORY_CONSTANTS = {\n  // Size limits\n  MAX_MEMORY_SIZE: 1024 * 1024,        // 1MB total memory size\n  MAX_ENTRY_SIZE: 100 * 1024,          // 100KB per entry\n  MAX_ENTRIES_DEFAULT: 1000,           // Maximum number of entries\n\n  // Entry limits\n  MAX_TAGS_PER_ENTRY: 20,              // Maximum tags per memory entry\n  MAX_TAG_LENGTH: 50,                  // Maximum length of each tag\n  MAX_METADATA_KEYS: 20,               // Maximum metadata keys per entry\n  MAX_METADATA_KEY_LENGTH: 50,         // Maximum metadata key length\n  MAX_METADATA_VALUE_LENGTH: 200,      // Maximum metadata value length\n\n  // Retention defaults\n  DEFAULT_RETENTION_DAYS: 30,          // Default retention period\n  MIN_RETENTION_DAYS: 1,               // Minimum retention period\n  MAX_RETENTION_DAYS: 365,             // Maximum retention period\n\n  // Search limits\n  DEFAULT_SEARCH_LIMIT: 100,           // Default search result limit\n\n  /**\n   * YAML Size Limit Rationale:\n   * 256KB is optimal for YAML parsing performance while preventing DoS attacks.\n   * - YAML parsing is CPU-intensive; large files can block the event loop\n   * - 256KB accommodates ~5000 lines of typical memory content\n   * - Larger memories should be sharded across multiple files\n   * - External references used for binary data (images, PDFs, etc)\n   *\n   * Performance benchmarks:\n   * - <256KB: Parse time <10ms on average hardware\n   * - 1MB: Parse time ~50-100ms (acceptable but not ideal)\n   * - >5MB: Parse time >500ms (unacceptable, blocks UI)\n   */\n  MAX_YAML_SIZE: 256 * 1024,           // 256KB max YAML size for import\n\n  /**\n   * Privacy Level Hierarchy:\n   *\n   * 'public' - Lowest restriction level\n   *   - Available to all contexts and users\n   *   - Can be shared across sessions\n   *   - Suitable for general knowledge, documentation\n   *   - Example: Project conventions, public APIs\n   *\n   * 'private' - Default level, moderate restriction\n   *   - Restricted to current user/session\n   *   - Not shared with other users\n   *   - Suitable for personal preferences, user-specific data\n   *   - Example: User's coding style, personal notes\n   *\n   * 'sensitive' - Highest restriction level\n   *   - Requires explicit permission to access\n   *   - Extra logging and audit trail\n   *   - Automatic deletion after retention period\n   *   - Suitable for credentials, PII, confidential data\n   *   - Example: API keys (temporary), personal information\n   *\n   * Access rules cascade: sensitive ⊂ private ⊂ public\n   */\n  PRIVACY_LEVELS: ['public', 'private', 'sensitive'] as const,\n  DEFAULT_PRIVACY_LEVEL: 'private' as const,\n  \n  // Storage backends\n  DEFAULT_STORAGE_BACKEND: 'memory' as const,\n  SUPPORTED_STORAGE_BACKENDS: ['memory', 'file', 'indexed'] as const,\n} as const;\n\n// Type exports for privacy levels and storage backends\nexport type PrivacyLevel = typeof MEMORY_CONSTANTS.PRIVACY_LEVELS[number];\nexport type StorageBackend = typeof MEMORY_CONSTANTS.SUPPORTED_STORAGE_BACKENDS[number];\n\n// Security event types for memory operations\nexport const MEMORY_SECURITY_EVENTS = {\n  MEMORY_CREATED: 'MEMORY_CREATED',\n  MEMORY_ADDED: 'MEMORY_ADDED',\n  MEMORY_SEARCHED: 'MEMORY_SEARCHED',\n  SENSITIVE_MEMORY_DELETED: 'SENSITIVE_MEMORY_DELETED',\n  RETENTION_POLICY_ENFORCED: 'RETENTION_POLICY_ENFORCED',\n  MEMORY_CLEARED: 'MEMORY_CLEARED',\n  MEMORY_LOADED: 'MEMORY_LOADED',\n  MEMORY_SAVED: 'MEMORY_SAVED',\n  MEMORY_DELETED: 'MEMORY_DELETED',\n  MEMORY_LOAD_FAILED: 'MEMORY_LOAD_FAILED',\n  MEMORY_SAVE_FAILED: 'MEMORY_SAVE_FAILED',\n  MEMORY_DESERIALIZE_FAILED: 'MEMORY_DESERIALIZE_FAILED',\n  MEMORY_LIST_ITEM_FAILED: 'MEMORY_LIST_ITEM_FAILED',\n  MEMORY_IMPORT_FAILED: 'MEMORY_IMPORT_FAILED',\n  MEMORY_INTEGRITY_VIOLATION: 'MEMORY_INTEGRITY_VIOLATION',\n  MEMORY_UNICODE_VALIDATION_FAILED: 'MEMORY_UNICODE_VALIDATION_FAILED',\n  MEMORY_DUPLICATE_DETECTED: 'MEMORY_DUPLICATE_DETECTED',\n} as const;"]}

package/dist/elements/memories/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memory element exports
+ */
+export { Memory, MemoryMetadata, MemoryEntry, MemorySearchOptions } from './Memory.js';
+export { MemoryManager } from './MemoryManager.js';
+export { MemorySearchIndex, SearchQuery, SearchIndexConfig, SearchResult } from './MemorySearchIndex.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/memories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/elements/memories/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/elements/memories/index.js

@@ -0,0 +1,7 @@
+/**
+ * Memory element exports
+ */
+export { Memory } from './Memory.js';
+export { MemoryManager } from './MemoryManager.js';
+export { MemorySearchIndex } from './MemorySearchIndex.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZWxlbWVudHMvbWVtb3JpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFvRCxNQUFNLGFBQWEsQ0FBQztBQUN2RixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxFQUFFLGlCQUFpQixFQUFnRCxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNZW1vcnkgZWxlbWVudCBleHBvcnRzXG4gKi9cblxuZXhwb3J0IHsgTWVtb3J5LCBNZW1vcnlNZXRhZGF0YSwgTWVtb3J5RW50cnksIE1lbW9yeVNlYXJjaE9wdGlvbnMgfSBmcm9tICcuL01lbW9yeS5qcyc7XG5leHBvcnQgeyBNZW1vcnlNYW5hZ2VyIH0gZnJvbSAnLi9NZW1vcnlNYW5hZ2VyLmpzJztcbmV4cG9ydCB7IE1lbW9yeVNlYXJjaEluZGV4LCBTZWFyY2hRdWVyeSwgU2VhcmNoSW5kZXhDb25maWcsIFNlYXJjaFJlc3VsdCB9IGZyb20gJy4vTWVtb3J5U2VhcmNoSW5kZXguanMnOyJdfQ==

package/dist/elements/memories/utils.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Utility functions for Memory element operations
+ *
+ * PERFORMANCE CONSIDERATIONS:
+ * - ID generation should be fast (<1ms)
+ * - Hash functions optimized for memory verification
+ * - Index operations designed for O(log n) complexity
+ *
+ * SECURITY CONSIDERATIONS:
+ * - Hash functions normalize Unicode to prevent bypass attempts
+ * - Content verification detects external modifications
+ * - Protects against manual editing and tampering
+ */
+/**
+ * Generate a unique ID for memory entries
+ * Format: mem_{timestamp}_{random}
+ *
+ * @returns Unique memory entry ID
+ * @example
+ * generateMemoryId() // "mem_1699234567890_x7k2n9p4m"
+ */
+export declare function generateMemoryId(): string;
+/**
+ * Generate a content hash for memory integrity verification
+ * Uses SHA-256 for cryptographic strength with Unicode normalization
+ *
+ * SECURITY: Normalizes content to prevent Unicode-based bypass attempts
+ * where attackers use homographs or invisible characters to create
+ * content that appears identical but has a different hash
+ *
+ * @param content - The content to hash (will be normalized)
+ * @returns Hex-encoded hash string
+ */
+export declare function generateContentHash(content: string): string;
+/**
+ * Verify memory content integrity
+ *
+ * SECURITY: This function detects:
+ * - External tool modifications (didn't use our hash function)
+ * - Manual human editing of YAML files
+ * - Filesystem corruption
+ * - Tampering attempts (including Unicode tricks)
+ *
+ * @param content - The content to verify (will be normalized)
+ * @param expectedHash - The expected hash value
+ * @returns True if content matches hash after normalization
+ */
+export declare function verifyContentIntegrity(content: string, expectedHash: string): boolean;
+/**
+ * Calculate shard key for memory distribution
+ * Used for distributing memories across multiple files
+ *
+ * SECURITY: Normalizes input to ensure consistent sharding
+ * regardless of Unicode representation
+ *
+ * @param memoryId - The memory ID (will be normalized)
+ * @param shardCount - Number of shards (default 16)
+ * @returns Shard index (0 to shardCount-1)
+ */
+export declare function calculateShardKey(memoryId: string, shardCount?: number): number;
+/**
+ * Parse memory ID to extract timestamp
+ *
+ * @param memoryId - The memory ID to parse
+ * @returns Timestamp or null if invalid format
+ */
+export declare function parseMemoryTimestamp(memoryId: string): number | null;
+//# sourceMappingURL=utils.d.ts.map

package/dist/elements/memories/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/elements/memories/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAIzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAmB3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAgBrF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,GAAG,MAAM,CAoB3E;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAOpE"}

package/dist/elements/memories/utils.js

@@ -0,0 +1,137 @@
+/**
+ * Utility functions for Memory element operations
+ *
+ * PERFORMANCE CONSIDERATIONS:
+ * - ID generation should be fast (<1ms)
+ * - Hash functions optimized for memory verification
+ * - Index operations designed for O(log n) complexity
+ *
+ * SECURITY CONSIDERATIONS:
+ * - Hash functions normalize Unicode to prevent bypass attempts
+ * - Content verification detects external modifications
+ * - Protects against manual editing and tampering
+ */
+import * as crypto from 'crypto';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { MEMORY_SECURITY_EVENTS } from './constants.js';
+/**
+ * Generate a unique ID for memory entries
+ * Format: mem_{timestamp}_{random}
+ *
+ * @returns Unique memory entry ID
+ * @example
+ * generateMemoryId() // "mem_1699234567890_x7k2n9p4m"
+ */
+export function generateMemoryId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substr(2, 9);
+    return `mem_${timestamp}_${random}`;
+}
+/**
+ * Generate a content hash for memory integrity verification
+ * Uses SHA-256 for cryptographic strength with Unicode normalization
+ *
+ * SECURITY: Normalizes content to prevent Unicode-based bypass attempts
+ * where attackers use homographs or invisible characters to create
+ * content that appears identical but has a different hash
+ *
+ * @param content - The content to hash (will be normalized)
+ * @returns Hex-encoded hash string
+ */
+export function generateContentHash(content) {
+    // SECURITY FIX: Normalize Unicode to prevent homograph attacks
+    // This ensures consistent hashing regardless of Unicode representation
+    const normalized = UnicodeValidator.normalize(content);
+    if (!normalized.isValid && normalized.detectedIssues) {
+        // Log potential security issue but still generate hash
+        // We want to detect the tampering, not reject it silently
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,
+            severity: 'MEDIUM',
+            source: 'generateContentHash',
+            details: `Unicode security issues detected: ${normalized.detectedIssues.join(', ')}`
+        });
+    }
+    return crypto.createHash('sha256')
+        .update(normalized.normalizedContent)
+        .digest('hex');
+}
+/**
+ * Verify memory content integrity
+ *
+ * SECURITY: This function detects:
+ * - External tool modifications (didn't use our hash function)
+ * - Manual human editing of YAML files
+ * - Filesystem corruption
+ * - Tampering attempts (including Unicode tricks)
+ *
+ * @param content - The content to verify (will be normalized)
+ * @param expectedHash - The expected hash value
+ * @returns True if content matches hash after normalization
+ */
+export function verifyContentIntegrity(content, expectedHash) {
+    const actualHash = generateContentHash(content);
+    const isValid = actualHash === expectedHash;
+    if (!isValid) {
+        // SECURITY: Log integrity violation for audit trail
+        // This could indicate external modification or tampering
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_INTEGRITY_VIOLATION,
+            severity: 'HIGH',
+            source: 'verifyContentIntegrity',
+            details: `Hash mismatch detected. Expected: ${expectedHash.substring(0, 8)}..., Got: ${actualHash.substring(0, 8)}...`
+        });
+    }
+    return isValid;
+}
+/**
+ * Calculate shard key for memory distribution
+ * Used for distributing memories across multiple files
+ *
+ * SECURITY: Normalizes input to ensure consistent sharding
+ * regardless of Unicode representation
+ *
+ * @param memoryId - The memory ID (will be normalized)
+ * @param shardCount - Number of shards (default 16)
+ * @returns Shard index (0 to shardCount-1)
+ */
+export function calculateShardKey(memoryId, shardCount = 16) {
+    // SECURITY FIX: Normalize memoryId to prevent Unicode-based attacks
+    // that could cause memories to be placed in unexpected shards
+    const normalized = UnicodeValidator.normalize(memoryId);
+    if (!normalized.isValid && normalized.detectedIssues) {
+        // Log but continue - we still need to calculate a shard
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,
+            severity: 'LOW',
+            source: 'calculateShardKey',
+            details: `Unicode issues in memory ID: ${normalized.detectedIssues.join(', ')}`
+        });
+    }
+    const hash = crypto.createHash('md5')
+        .update(normalized.normalizedContent)
+        .digest();
+    const hashInt = hash.readUInt32BE(0);
+    return hashInt % shardCount;
+}
+/**
+ * Parse memory ID to extract timestamp
+ *
+ * @param memoryId - The memory ID to parse
+ * @returns Timestamp or null if invalid format
+ */
+export function parseMemoryTimestamp(memoryId) {
+    const match = memoryId.match(/^mem_(\d+)_/);
+    if (match && match[1]) {
+        const timestamp = parseInt(match[1], 10);
+        return isNaN(timestamp) ? null : timestamp;
+    }
+    return null;
+}
+// TODO: Future index utilities
+// - createMemoryIndex(): Create B-tree or similar structure for fast lookups
+// - updateIndex(): Update index when memories are added/removed
+// - searchIndex(): O(log n) search through indexed memories
+// - mergeIndices(): Combine multiple index files for distributed search
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/elements/memories/utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Utility functions for Memory element operations\n *\n * PERFORMANCE CONSIDERATIONS:\n * - ID generation should be fast (<1ms)\n * - Hash functions optimized for memory verification\n * - Index operations designed for O(log n) complexity\n *\n * SECURITY CONSIDERATIONS:\n * - Hash functions normalize Unicode to prevent bypass attempts\n * - Content verification detects external modifications\n * - Protects against manual editing and tampering\n */\n\nimport * as crypto from 'crypto';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { MEMORY_SECURITY_EVENTS } from './constants.js';\n\n/**\n * Generate a unique ID for memory entries\n * Format: mem_{timestamp}_{random}\n *\n * @returns Unique memory entry ID\n * @example\n * generateMemoryId() // \"mem_1699234567890_x7k2n9p4m\"\n */\nexport function generateMemoryId(): string {\n  const timestamp = Date.now();\n  const random = Math.random().toString(36).substr(2, 9);\n  return `mem_${timestamp}_${random}`;\n}\n\n/**\n * Generate a content hash for memory integrity verification\n * Uses SHA-256 for cryptographic strength with Unicode normalization\n *\n * SECURITY: Normalizes content to prevent Unicode-based bypass attempts\n * where attackers use homographs or invisible characters to create\n * content that appears identical but has a different hash\n *\n * @param content - The content to hash (will be normalized)\n * @returns Hex-encoded hash string\n */\nexport function generateContentHash(content: string): string {\n  // SECURITY FIX: Normalize Unicode to prevent homograph attacks\n  // This ensures consistent hashing regardless of Unicode representation\n  const normalized = UnicodeValidator.normalize(content);\n\n  if (!normalized.isValid && normalized.detectedIssues) {\n    // Log potential security issue but still generate hash\n    // We want to detect the tampering, not reject it silently\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,\n      severity: 'MEDIUM',\n      source: 'generateContentHash',\n      details: `Unicode security issues detected: ${normalized.detectedIssues.join(', ')}`\n    });\n  }\n\n  return crypto.createHash('sha256')\n    .update(normalized.normalizedContent)\n    .digest('hex');\n}\n\n/**\n * Verify memory content integrity\n *\n * SECURITY: This function detects:\n * - External tool modifications (didn't use our hash function)\n * - Manual human editing of YAML files\n * - Filesystem corruption\n * - Tampering attempts (including Unicode tricks)\n *\n * @param content - The content to verify (will be normalized)\n * @param expectedHash - The expected hash value\n * @returns True if content matches hash after normalization\n */\nexport function verifyContentIntegrity(content: string, expectedHash: string): boolean {\n  const actualHash = generateContentHash(content);\n  const isValid = actualHash === expectedHash;\n\n  if (!isValid) {\n    // SECURITY: Log integrity violation for audit trail\n    // This could indicate external modification or tampering\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_INTEGRITY_VIOLATION,\n      severity: 'HIGH',\n      source: 'verifyContentIntegrity',\n      details: `Hash mismatch detected. Expected: ${expectedHash.substring(0, 8)}..., Got: ${actualHash.substring(0, 8)}...`\n    });\n  }\n\n  return isValid;\n}\n\n/**\n * Calculate shard key for memory distribution\n * Used for distributing memories across multiple files\n *\n * SECURITY: Normalizes input to ensure consistent sharding\n * regardless of Unicode representation\n *\n * @param memoryId - The memory ID (will be normalized)\n * @param shardCount - Number of shards (default 16)\n * @returns Shard index (0 to shardCount-1)\n */\nexport function calculateShardKey(memoryId: string, shardCount = 16): number {\n  // SECURITY FIX: Normalize memoryId to prevent Unicode-based attacks\n  // that could cause memories to be placed in unexpected shards\n  const normalized = UnicodeValidator.normalize(memoryId);\n\n  if (!normalized.isValid && normalized.detectedIssues) {\n    // Log but continue - we still need to calculate a shard\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,\n      severity: 'LOW',\n      source: 'calculateShardKey',\n      details: `Unicode issues in memory ID: ${normalized.detectedIssues.join(', ')}`\n    });\n  }\n\n  const hash = crypto.createHash('md5')\n    .update(normalized.normalizedContent)\n    .digest();\n  const hashInt = hash.readUInt32BE(0);\n  return hashInt % shardCount;\n}\n\n/**\n * Parse memory ID to extract timestamp\n *\n * @param memoryId - The memory ID to parse\n * @returns Timestamp or null if invalid format\n */\nexport function parseMemoryTimestamp(memoryId: string): number | null {\n  const match = memoryId.match(/^mem_(\\d+)_/);\n  if (match && match[1]) {\n    const timestamp = parseInt(match[1], 10);\n    return isNaN(timestamp) ? null : timestamp;\n  }\n  return null;\n}\n\n// TODO: Future index utilities\n// - createMemoryIndex(): Create B-tree or similar structure for fast lookups\n// - updateIndex(): Update index when memories are added/removed\n// - searchIndex(): O(log n) search through indexed memories\n// - mergeIndices(): Combine multiple index files for distributed search"]}

package/dist/generated/version.d.ts

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export declare const PACKAGE_VERSION = "1.8.0";
-export declare const BUILD_TIMESTAMP = "2025-09-15T17:34:06.605Z";
+export declare const PACKAGE_VERSION = "1.9.0";
+export declare const BUILD_TIMESTAMP = "2025-09-19T14:39:55.094Z";
 export declare const BUILD_TYPE: 'npm' | 'git';
 export declare const PACKAGE_NAME = "@dollhousemcp/mcp-server";
 //# sourceMappingURL=version.d.ts.map

package/dist/generated/version.js

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export const PACKAGE_VERSION = '1.8.0';
-export const BUILD_TIMESTAMP = '2025-09-15T17:34:06.605Z';
+export const PACKAGE_VERSION = '1.9.0';
+export const BUILD_TIMESTAMP = '2025-09-19T14:39:55.094Z';
 export const BUILD_TYPE = 'npm';
 export const PACKAGE_NAME = '@dollhousemcp/mcp-server';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcxLjguMCc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjUtMDktMTVUMTc6MzQ6MDYuNjA1Wic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsT0FBTyxDQUFDO0FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcxLjkuMCc7XG5leHBvcnQgY29uc3QgQlVJTERfVElNRVNUQU1QID0gJzIwMjUtMDktMTlUMTQ6Mzk6NTUuMDk0Wic7XG5leHBvcnQgY29uc3QgQlVJTERfVFlQRTogJ25wbScgfCAnZ2l0JyA9ICducG0nO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfTkFNRSA9ICdAZG9sbGhvdXNlbWNwL21jcC1zZXJ2ZXInO1xuIl19

package/dist/scripts/scripts/run-config-wizard.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Standalone script to run the configuration wizard
+ * Can be used for testing or manual configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runConfigWizard = main;
+const ConfigManager_js_1 = require("../src/config/ConfigManager.js");
+const ConfigWizard_js_1 = require("../src/config/ConfigWizard.js");
+const chalk_1 = require("chalk");
+async function main() {
+    try {
+        // Initialize config manager
+        const configManager = ConfigManager_js_1.ConfigManager.getInstance();
+        await configManager.initialize();
+        // Create and run wizard
+        const wizard = new ConfigWizard_js_1.ConfigWizard(configManager);
+        // Check if we should force run (for testing)
+        const forceRun = process.argv.includes('--force');
+        if (forceRun || await wizard.shouldRunWizard()) {
+            const choice = await wizard.promptInitial();
+            if (choice === 'yes') {
+                await wizard.runWizard();
+            }
+            else if (choice === 'never') {
+                await wizard.markDismissed();
+                console.log(chalk_1.default.gray('\nWizard dismissed. You can run it manually anytime.\n'));
+            }
+            else {
+                console.log(chalk_1.default.gray('\nSkipped for now. The wizard will ask again next time.\n'));
+            }
+        }
+        else {
+            const config = configManager.getConfig();
+            if (config.wizard?.completed) {
+                console.log(chalk_1.default.green('\n✅ Configuration wizard already completed.'));
+                console.log(chalk_1.default.gray('Use --force to run it again.\n'));
+            }
+            else if (config.wizard?.dismissed) {
+                console.log(chalk_1.default.yellow('\n⚠️  Configuration wizard was previously dismissed.'));
+                console.log(chalk_1.default.gray('Use --force to run it anyway.\n'));
+            }
+        }
+        // Clean up
+        wizard.close();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n❌ Error running configuration wizard:'), error);
+        process.exit(1);
+    }
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}