@dollhousemcp/mcp-server 1.3.0

package/dist/elements/memories/MemoryManager.js

@@ -0,0 +1,435 @@
+/**
+ * MemoryManager - Implementation of IElementManager for Memory elements
+ * Handles CRUD operations and lifecycle management for memories implementing IElement
+ *
+ * FIXES IMPLEMENTED:
+ * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes
+ * 2. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser
+ * 3. MEDIUM: All user inputs are now validated and sanitized
+ * 4. MEDIUM: Audit logging added for security operations
+ * 5. MEDIUM: Path validation prevents directory traversal attacks
+ */
+import { Memory } from './Memory.js';
+import { ElementType } from '../../portfolio/types.js';
+import { PortfolioManager } from '../../portfolio/PortfolioManager.js';
+import { FileLockManager } from '../../security/fileLockManager.js';
+import { SecureYamlParser } from '../../security/secureYamlParser.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as yaml from 'js-yaml';
+export class MemoryManager {
+    portfolioManager;
+    memoriesDir;
+    memoryCache = new Map();
+    constructor() {
+        this.portfolioManager = PortfolioManager.getInstance();
+        this.memoriesDir = this.portfolioManager.getElementDir(ElementType.MEMORY);
+    }
+    /**
+     * Load a memory from file
+     * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()
+     * to prevent race conditions and ensure atomic file operations
+     */
+    async load(filePath) {
+        try {
+            // Validate and resolve path
+            const fullPath = await this.validateAndResolvePath(filePath);
+            // Check cache first
+            const cached = this.memoryCache.get(fullPath);
+            if (cached) {
+                return cached;
+            }
+            // CRITICAL FIX: Use atomic file read to prevent race conditions
+            // Previously: const content = await fs.readFile(fullPath, 'utf-8');
+            // Now: Uses FileLockManager with proper encoding object format
+            const content = await FileLockManager.atomicReadFile(fullPath, { encoding: 'utf-8' });
+            // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection attacks
+            // Previously: Could use unsafe YAML parsing
+            // Now: Uses SecureYamlParser which validates content and prevents malicious patterns
+            const parsed = SecureYamlParser.parse(content, {
+                maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,
+                validateContent: true
+            });
+            // Extract metadata and content
+            const { metadata, content: memoryContent } = this.parseMemoryFile(parsed);
+            // Create memory instance
+            const memory = new Memory(metadata);
+            // Load saved entries if present
+            if (parsed.data && parsed.data.entries) {
+                memory.deserialize(JSON.stringify({
+                    id: memory.id,
+                    type: memory.type,
+                    version: memory.version,
+                    metadata: memory.metadata,
+                    extensions: memory.extensions,
+                    entries: parsed.data.entries
+                }));
+            }
+            // Cache the loaded memory
+            this.memoryCache.set(fullPath, memory);
+            // Log successful load
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_LOADED,
+                severity: 'LOW',
+                source: 'MemoryManager.load',
+                details: `Loaded memory from ${path.basename(fullPath)}`
+            });
+            return memory;
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_LOAD_FAILED,
+                severity: 'MEDIUM',
+                source: 'MemoryManager.load',
+                details: `Failed to load memory from ${filePath}: ${error}`
+            });
+            throw new Error(`Failed to load memory: ${error}`);
+        }
+    }
+    /**
+     * Save a memory to file
+     * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() for atomic operations
+     */
+    async save(element, filePath) {
+        try {
+            // Validate element
+            const validation = element.validate();
+            if (!validation.valid) {
+                throw new Error(`Invalid memory: ${validation.errors?.map(e => e.message).join(', ')}`);
+            }
+            // Validate and resolve path
+            const fullPath = await this.validateAndResolvePath(filePath);
+            // Get memory statistics
+            const stats = element.getStats();
+            // Prepare data for saving
+            const data = {
+                metadata: element.metadata,
+                extensions: element.extensions,
+                stats: {
+                    totalEntries: stats.totalEntries,
+                    totalSize: stats.totalSize,
+                    oldestEntry: stats.oldestEntry?.toISOString(),
+                    newestEntry: stats.newestEntry?.toISOString(),
+                    topTags: Array.from(stats.tagFrequency.entries())
+                        .sort((a, b) => b[1] - a[1])
+                        .slice(0, 10)
+                        .map(([tag, count]) => ({ tag, count }))
+                },
+                entries: JSON.parse(element.serialize()).entries
+            };
+            // SECURITY FIX: Use secure YAML dumping with safety options
+            // Previously: Could allow dangerous YAML features
+            // Now: Uses FAILSAFE_SCHEMA and security options to prevent code execution
+            const yamlContent = yaml.dump(data, {
+                schema: yaml.FAILSAFE_SCHEMA,
+                noRefs: true,
+                skipInvalid: true,
+                sortKeys: true
+            });
+            // CRITICAL FIX: Use atomic file write to prevent corruption
+            // Previously: await fs.writeFile(fullPath, yamlContent, 'utf-8');
+            // Now: Uses FileLockManager for atomic write with proper encoding
+            await FileLockManager.atomicWriteFile(fullPath, yamlContent, { encoding: 'utf-8' });
+            // Update cache
+            this.memoryCache.set(fullPath, element);
+            // Log successful save
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_SAVED,
+                severity: 'LOW',
+                source: 'MemoryManager.save',
+                details: `Saved memory to ${path.basename(fullPath)} with ${stats.totalEntries} entries`
+            });
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_SAVE_FAILED,
+                severity: 'HIGH',
+                source: 'MemoryManager.save',
+                details: `Failed to save memory to ${filePath}: ${error}`
+            });
+            throw new Error(`Failed to save memory: ${error}`);
+        }
+    }
+    /**
+     * List all available memories
+     */
+    async list() {
+        try {
+            const files = await fs.readdir(this.memoriesDir);
+            const memories = [];
+            for (const file of files) {
+                if (file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml')) {
+                    try {
+                        const memory = await this.load(file);
+                        memories.push(memory);
+                    }
+                    catch (error) {
+                        // Log but continue with other files
+                        SecurityMonitor.logSecurityEvent({
+                            type: MEMORY_SECURITY_EVENTS.MEMORY_LIST_ITEM_FAILED,
+                            severity: 'LOW',
+                            source: 'MemoryManager.list',
+                            details: `Failed to load ${file}: ${error}`
+                        });
+                    }
+                }
+            }
+            return memories;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Directory doesn't exist yet
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Find memories matching a predicate
+     */
+    async find(predicate) {
+        const memories = await this.list();
+        return memories.find(predicate);
+    }
+    /**
+     * Find multiple memories matching a predicate
+     */
+    async findMany(predicate) {
+        const memories = await this.list();
+        return memories.filter(predicate);
+    }
+    /**
+     * Delete a memory file
+     * SECURITY: Validates path and logs deletion
+     */
+    async delete(filePath) {
+        try {
+            const fullPath = await this.validateAndResolvePath(filePath);
+            // Check if file exists
+            await fs.access(fullPath);
+            // Delete the file
+            await fs.unlink(fullPath);
+            // Remove from cache
+            this.memoryCache.delete(fullPath);
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_DELETED,
+                severity: 'MEDIUM',
+                source: 'MemoryManager.delete',
+                details: `Deleted memory file: ${path.basename(fullPath)}`
+            });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist, not an error for delete operation
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if a memory file exists
+     */
+    async exists(filePath) {
+        try {
+            const fullPath = await this.validateAndResolvePath(filePath);
+            await fs.access(fullPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create a new memory with metadata
+     */
+    async create(metadata) {
+        return new Memory(metadata);
+    }
+    /**
+     * Import a memory from JSON/YAML string
+     * SECURITY: Full validation of imported content
+     */
+    async importElement(data, format = 'yaml') {
+        try {
+            let parsed;
+            if (format === 'json') {
+                parsed = JSON.parse(data);
+            }
+            else {
+                // HIGH SEVERITY FIX: Use secure YAML parsing
+                // Memory import expects pure YAML (not frontmatter), so we parse it securely
+                try {
+                    // First validate the YAML content size
+                    if (data.length > MEMORY_CONSTANTS.MAX_YAML_SIZE) {
+                        throw new Error('YAML content exceeds maximum allowed size');
+                    }
+                    // Create a wrapper to use SecureYamlParser with pure YAML
+                    // Add minimal frontmatter markers to satisfy parser
+                    const wrappedYaml = `---\n${data}\n---\n`;
+                    const parseResult = SecureYamlParser.parse(wrappedYaml, {
+                        maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,
+                        validateContent: true
+                    });
+                    // Extract the parsed data (will be in the 'data' property)
+                    parsed = parseResult.data;
+                }
+                catch (yamlError) {
+                    throw new Error(`Invalid YAML: ${yamlError}`);
+                }
+                // Validate it's an object
+                if (!parsed || typeof parsed !== 'object') {
+                    throw new Error('YAML must contain an object');
+                }
+            }
+            // Handle different structures from YAML parsing
+            let metadata = parsed.metadata;
+            let entries = parsed.entries || (parsed.data && parsed.data.entries);
+            // Validate required fields
+            if (!metadata || !metadata.name) {
+                throw new Error('Memory must have metadata with name');
+            }
+            // Create memory instance
+            const memory = new Memory(metadata);
+            // Load entries if present
+            if (entries) {
+                memory.deserialize(JSON.stringify({
+                    id: memory.id,
+                    type: memory.type,
+                    version: memory.version,
+                    metadata: memory.metadata,
+                    extensions: memory.extensions,
+                    entries: entries
+                }));
+            }
+            return memory;
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_IMPORT_FAILED,
+                severity: 'MEDIUM',
+                source: 'MemoryManager.importElement',
+                details: `Failed to import memory: ${error}`
+            });
+            throw new Error(`Failed to import memory: ${error}`);
+        }
+    }
+    /**
+     * Export a memory to YAML string
+     */
+    async exportElement(element) {
+        const stats = element.getStats();
+        const data = {
+            metadata: element.metadata,
+            extensions: element.extensions,
+            stats: {
+                totalEntries: stats.totalEntries,
+                totalSize: stats.totalSize,
+                oldestEntry: stats.oldestEntry?.toISOString(),
+                newestEntry: stats.newestEntry?.toISOString()
+            },
+            entries: JSON.parse(element.serialize()).entries
+        };
+        // SECURITY FIX: Use secure YAML dumping
+        return yaml.dump(data, {
+            schema: yaml.FAILSAFE_SCHEMA,
+            noRefs: true,
+            skipInvalid: true,
+            sortKeys: true
+        });
+    }
+    /**
+     * Validate a memory element
+     */
+    validate(element) {
+        return element.validate();
+    }
+    /**
+     * Validate and resolve a file path
+     * SECURITY: Prevents directory traversal attacks
+     */
+    validatePath(filePath) {
+        try {
+            // Perform synchronous validation checks
+            const normalized = path.normalize(filePath);
+            // Check for path traversal attempts
+            if (normalized.includes('..') || path.isAbsolute(normalized)) {
+                return false;
+            }
+            // Ensure proper extension
+            if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {
+                return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the element type this manager handles
+     */
+    getElementType() {
+        return ElementType.MEMORY;
+    }
+    /**
+     * Get the file extension for memory files
+     */
+    getFileExtension() {
+        return '.yaml';
+    }
+    // Private helper methods
+    async validateAndResolvePath(filePath) {
+        // SECURITY FIX: Comprehensive path validation
+        const normalized = path.normalize(filePath);
+        // Check for path traversal attempts
+        if (normalized.includes('..') || path.isAbsolute(normalized)) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'PATH_TRAVERSAL_ATTEMPT',
+                severity: 'HIGH',
+                source: 'MemoryManager.validateAndResolvePath',
+                details: `Blocked path traversal attempt: ${filePath}`
+            });
+            throw new Error('Invalid file path: Path traversal detected');
+        }
+        // Ensure proper extension
+        if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {
+            throw new Error('Memory files must have .md, .yaml, or .yml extension');
+        }
+        // Construct full path
+        const fullPath = path.join(this.memoriesDir, normalized);
+        // Verify it's within memories directory
+        const relative = path.relative(this.memoriesDir, fullPath);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error('File path must be within memories directory');
+        }
+        return fullPath;
+    }
+    parseMemoryFile(parsed) {
+        // Extract metadata with validation
+        const metadata = {
+            name: sanitizeInput(parsed.metadata?.name || 'Unnamed Memory', 100),
+            description: parsed.metadata?.description ?
+                sanitizeInput(parsed.metadata.description, 500) :
+                '',
+            version: parsed.metadata?.version || '1.0.0',
+            author: parsed.metadata?.author,
+            created: parsed.metadata?.created,
+            modified: new Date().toISOString(),
+            tags: Array.isArray(parsed.metadata?.tags) ?
+                parsed.metadata.tags.map((tag) => sanitizeInput(tag, 50)) :
+                [],
+            storageBackend: parsed.metadata?.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND,
+            retentionDays: parsed.metadata?.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS,
+            privacyLevel: parsed.metadata?.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL,
+            searchable: parsed.metadata?.searchable !== false,
+            maxEntries: parsed.metadata?.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT
+        };
+        // Extract content (if any)
+        const content = parsed.content || '';
+        return { metadata, content };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryManager.js","sourceRoot":"","sources":["../../../src/elements/memories/MemoryManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MemoryManager - Implementation of IElementManager for Memory elements\n * Handles CRUD operations and lifecycle management for memories implementing IElement\n * \n * FIXES IMPLEMENTED:\n * 1. CRITICAL: Fixed race conditions in file operations by using FileLockManager for atomic reads/writes\n * 2. HIGH: Fixed unvalidated YAML parsing vulnerability by using SecureYamlParser\n * 3. MEDIUM: All user inputs are now validated and sanitized\n * 4. MEDIUM: Audit logging added for security operations\n * 5. MEDIUM: Path validation prevents directory traversal attacks\n */\n\nimport { Memory, MemoryMetadata, MemoryEntry } from './Memory.js';\nimport { IElementManager } from '../../types/elements/IElementManager.js';\nimport { ElementValidationResult } from '../../types/elements/IElement.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { PortfolioManager } from '../../portfolio/PortfolioManager.js';\nimport { FileLockManager } from '../../security/fileLockManager.js';\nimport { SecureYamlParser } from '../../security/secureYamlParser.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';\nimport * as path from 'path';\nimport * as fs from 'fs/promises';\nimport * as yaml from 'js-yaml';\n\nexport class MemoryManager implements IElementManager<Memory> {\n  private portfolioManager: PortfolioManager;\n  private memoriesDir: string;\n  private memoryCache: Map<string, Memory> = new Map();\n  \n  constructor() {\n    this.portfolioManager = PortfolioManager.getInstance();\n    this.memoriesDir = this.portfolioManager.getElementDir(ElementType.MEMORY);\n  }\n  \n  /**\n   * Load a memory from file\n   * SECURITY FIX #1: Uses FileLockManager.atomicReadFile() instead of fs.readFile()\n   * to prevent race conditions and ensure atomic file operations\n   */\n  async load(filePath: string): Promise<Memory> {\n    try {\n      // Validate and resolve path\n      const fullPath = await this.validateAndResolvePath(filePath);\n      \n      // Check cache first\n      const cached = this.memoryCache.get(fullPath);\n      if (cached) {\n        return cached;\n      }\n      \n      // CRITICAL FIX: Use atomic file read to prevent race conditions\n      // Previously: const content = await fs.readFile(fullPath, 'utf-8');\n      // Now: Uses FileLockManager with proper encoding object format\n      const content = await FileLockManager.atomicReadFile(fullPath, { encoding: 'utf-8' });\n      \n      // HIGH SEVERITY FIX: Use SecureYamlParser to prevent YAML injection attacks\n      // Previously: Could use unsafe YAML parsing\n      // Now: Uses SecureYamlParser which validates content and prevents malicious patterns\n      const parsed = SecureYamlParser.parse(content, {\n        maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,\n        validateContent: true\n      });\n      \n      // Extract metadata and content\n      const { metadata, content: memoryContent } = this.parseMemoryFile(parsed);\n      \n      // Create memory instance\n      const memory = new Memory(metadata);\n      \n      // Load saved entries if present\n      if (parsed.data && parsed.data.entries) {\n        memory.deserialize(JSON.stringify({\n          id: memory.id,\n          type: memory.type,\n          version: memory.version,\n          metadata: memory.metadata,\n          extensions: memory.extensions,\n          entries: parsed.data.entries\n        }));\n      }\n      \n      // Cache the loaded memory\n      this.memoryCache.set(fullPath, memory);\n      \n      // Log successful load\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_LOADED,\n        severity: 'LOW',\n        source: 'MemoryManager.load',\n        details: `Loaded memory from ${path.basename(fullPath)}`\n      });\n      \n      return memory;\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_LOAD_FAILED,\n        severity: 'MEDIUM',\n        source: 'MemoryManager.load',\n        details: `Failed to load memory from ${filePath}: ${error}`\n      });\n      throw new Error(`Failed to load memory: ${error}`);\n    }\n  }\n  \n  /**\n   * Save a memory to file\n   * SECURITY FIX #1: Uses FileLockManager.atomicWriteFile() for atomic operations\n   */\n  async save(element: Memory, filePath: string): Promise<void> {\n    try {\n      // Validate element\n      const validation = element.validate();\n      if (!validation.valid) {\n        throw new Error(`Invalid memory: ${validation.errors?.map(e => e.message).join(', ')}`);\n      }\n      \n      // Validate and resolve path\n      const fullPath = await this.validateAndResolvePath(filePath);\n      \n      // Get memory statistics\n      const stats = element.getStats();\n      \n      // Prepare data for saving\n      const data = {\n        metadata: element.metadata,\n        extensions: element.extensions,\n        stats: {\n          totalEntries: stats.totalEntries,\n          totalSize: stats.totalSize,\n          oldestEntry: stats.oldestEntry?.toISOString(),\n          newestEntry: stats.newestEntry?.toISOString(),\n          topTags: Array.from(stats.tagFrequency.entries())\n            .sort((a, b) => b[1] - a[1])\n            .slice(0, 10)\n            .map(([tag, count]) => ({ tag, count }))\n        },\n        entries: JSON.parse(element.serialize()).entries\n      };\n      \n      // SECURITY FIX: Use secure YAML dumping with safety options\n      // Previously: Could allow dangerous YAML features\n      // Now: Uses FAILSAFE_SCHEMA and security options to prevent code execution\n      const yamlContent = yaml.dump(data, {\n        schema: yaml.FAILSAFE_SCHEMA,\n        noRefs: true,\n        skipInvalid: true,\n        sortKeys: true\n      });\n      \n      // CRITICAL FIX: Use atomic file write to prevent corruption\n      // Previously: await fs.writeFile(fullPath, yamlContent, 'utf-8');\n      // Now: Uses FileLockManager for atomic write with proper encoding\n      await FileLockManager.atomicWriteFile(fullPath, yamlContent, { encoding: 'utf-8' });\n      \n      // Update cache\n      this.memoryCache.set(fullPath, element);\n      \n      // Log successful save\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_SAVED,\n        severity: 'LOW',\n        source: 'MemoryManager.save',\n        details: `Saved memory to ${path.basename(fullPath)} with ${stats.totalEntries} entries`\n      });\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_SAVE_FAILED,\n        severity: 'HIGH',\n        source: 'MemoryManager.save',\n        details: `Failed to save memory to ${filePath}: ${error}`\n      });\n      throw new Error(`Failed to save memory: ${error}`);\n    }\n  }\n  \n  /**\n   * List all available memories\n   */\n  async list(): Promise<Memory[]> {\n    try {\n      const files = await fs.readdir(this.memoriesDir);\n      const memories: Memory[] = [];\n      \n      for (const file of files) {\n        if (file.endsWith('.md') || file.endsWith('.yaml') || file.endsWith('.yml')) {\n          try {\n            const memory = await this.load(file);\n            memories.push(memory);\n          } catch (error) {\n            // Log but continue with other files\n            SecurityMonitor.logSecurityEvent({\n              type: MEMORY_SECURITY_EVENTS.MEMORY_LIST_ITEM_FAILED,\n              severity: 'LOW',\n              source: 'MemoryManager.list',\n              details: `Failed to load ${file}: ${error}`\n            });\n          }\n        }\n      }\n      \n      return memories;\n      \n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        // Directory doesn't exist yet\n        return [];\n      }\n      throw error;\n    }\n  }\n  \n  /**\n   * Find memories matching a predicate\n   */\n  async find(predicate: (element: Memory) => boolean): Promise<Memory | undefined> {\n    const memories = await this.list();\n    return memories.find(predicate);\n  }\n  \n  /**\n   * Find multiple memories matching a predicate\n   */\n  async findMany(predicate: (element: Memory) => boolean): Promise<Memory[]> {\n    const memories = await this.list();\n    return memories.filter(predicate);\n  }\n  \n  /**\n   * Delete a memory file\n   * SECURITY: Validates path and logs deletion\n   */\n  async delete(filePath: string): Promise<void> {\n    try {\n      const fullPath = await this.validateAndResolvePath(filePath);\n      \n      // Check if file exists\n      await fs.access(fullPath);\n      \n      // Delete the file\n      await fs.unlink(fullPath);\n      \n      // Remove from cache\n      this.memoryCache.delete(fullPath);\n      \n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_DELETED,\n        severity: 'MEDIUM',\n        source: 'MemoryManager.delete',\n        details: `Deleted memory file: ${path.basename(fullPath)}`\n      });\n      \n    } catch (error) {\n      if ((error as any).code === 'ENOENT') {\n        // File doesn't exist, not an error for delete operation\n        return;\n      }\n      throw error;\n    }\n  }\n  \n  /**\n   * Check if a memory file exists\n   */\n  async exists(filePath: string): Promise<boolean> {\n    try {\n      const fullPath = await this.validateAndResolvePath(filePath);\n      await fs.access(fullPath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n  \n  /**\n   * Create a new memory with metadata\n   */\n  async create(metadata: Partial<MemoryMetadata>): Promise<Memory> {\n    return new Memory(metadata);\n  }\n  \n  /**\n   * Import a memory from JSON/YAML string\n   * SECURITY: Full validation of imported content\n   */\n  async importElement(data: string, format: 'json' | 'yaml' = 'yaml'): Promise<Memory> {\n    try {\n      let parsed: any;\n      \n      if (format === 'json') {\n        parsed = JSON.parse(data);\n      } else {\n        // HIGH SEVERITY FIX: Use secure YAML parsing\n        // Memory import expects pure YAML (not frontmatter), so we parse it securely\n        try {\n          // First validate the YAML content size\n          if (data.length > MEMORY_CONSTANTS.MAX_YAML_SIZE) {\n            throw new Error('YAML content exceeds maximum allowed size');\n          }\n          \n          // Create a wrapper to use SecureYamlParser with pure YAML\n          // Add minimal frontmatter markers to satisfy parser\n          const wrappedYaml = `---\\n${data}\\n---\\n`;\n          \n          const parseResult = SecureYamlParser.parse(wrappedYaml, {\n            maxYamlSize: MEMORY_CONSTANTS.MAX_YAML_SIZE,\n            validateContent: true\n          });\n          \n          // Extract the parsed data (will be in the 'data' property)\n          parsed = parseResult.data;\n          \n        } catch (yamlError) {\n          throw new Error(`Invalid YAML: ${yamlError}`);\n        }\n        \n        // Validate it's an object\n        if (!parsed || typeof parsed !== 'object') {\n          throw new Error('YAML must contain an object');\n        }\n      }\n      \n      // Handle different structures from YAML parsing\n      let metadata = parsed.metadata;\n      let entries = parsed.entries || (parsed.data && parsed.data.entries);\n      \n      // Validate required fields\n      if (!metadata || !metadata.name) {\n        throw new Error('Memory must have metadata with name');\n      }\n      \n      // Create memory instance\n      const memory = new Memory(metadata);\n      \n      // Load entries if present\n      if (entries) {\n        memory.deserialize(JSON.stringify({\n          id: memory.id,\n          type: memory.type,\n          version: memory.version,\n          metadata: memory.metadata,\n          extensions: memory.extensions,\n          entries: entries\n        }));\n      }\n      \n      return memory;\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_IMPORT_FAILED,\n        severity: 'MEDIUM',\n        source: 'MemoryManager.importElement',\n        details: `Failed to import memory: ${error}`\n      });\n      throw new Error(`Failed to import memory: ${error}`);\n    }\n  }\n  \n  /**\n   * Export a memory to YAML string\n   */\n  async exportElement(element: Memory): Promise<string> {\n    const stats = element.getStats();\n    const data = {\n      metadata: element.metadata,\n      extensions: element.extensions,\n      stats: {\n        totalEntries: stats.totalEntries,\n        totalSize: stats.totalSize,\n        oldestEntry: stats.oldestEntry?.toISOString(),\n        newestEntry: stats.newestEntry?.toISOString()\n      },\n      entries: JSON.parse(element.serialize()).entries\n    };\n    \n    // SECURITY FIX: Use secure YAML dumping\n    return yaml.dump(data, {\n      schema: yaml.FAILSAFE_SCHEMA,\n      noRefs: true,\n      skipInvalid: true,\n      sortKeys: true\n    });\n  }\n  \n  /**\n   * Validate a memory element\n   */\n  validate(element: Memory): ElementValidationResult {\n    return element.validate();\n  }\n  \n  /**\n   * Validate and resolve a file path\n   * SECURITY: Prevents directory traversal attacks\n   */\n  validatePath(filePath: string): boolean {\n    try {\n      // Perform synchronous validation checks\n      const normalized = path.normalize(filePath);\n      \n      // Check for path traversal attempts\n      if (normalized.includes('..') || path.isAbsolute(normalized)) {\n        return false;\n      }\n      \n      // Ensure proper extension\n      if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {\n        return false;\n      }\n      \n      return true;\n    } catch {\n      return false;\n    }\n  }\n  \n  /**\n   * Get the element type this manager handles\n   */\n  getElementType(): ElementType {\n    return ElementType.MEMORY;\n  }\n  \n  /**\n   * Get the file extension for memory files\n   */\n  getFileExtension(): string {\n    return '.yaml';\n  }\n  \n  // Private helper methods\n  \n  private async validateAndResolvePath(filePath: string): Promise<string> {\n    // SECURITY FIX: Comprehensive path validation\n    const normalized = path.normalize(filePath);\n    \n    // Check for path traversal attempts\n    if (normalized.includes('..') || path.isAbsolute(normalized)) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'PATH_TRAVERSAL_ATTEMPT',\n        severity: 'HIGH',\n        source: 'MemoryManager.validateAndResolvePath',\n        details: `Blocked path traversal attempt: ${filePath}`\n      });\n      throw new Error('Invalid file path: Path traversal detected');\n    }\n    \n    // Ensure proper extension\n    if (!normalized.endsWith('.md') && !normalized.endsWith('.yaml') && !normalized.endsWith('.yml')) {\n      throw new Error('Memory files must have .md, .yaml, or .yml extension');\n    }\n    \n    // Construct full path\n    const fullPath = path.join(this.memoriesDir, normalized);\n    \n    // Verify it's within memories directory\n    const relative = path.relative(this.memoriesDir, fullPath);\n    if (relative.startsWith('..') || path.isAbsolute(relative)) {\n      throw new Error('File path must be within memories directory');\n    }\n    \n    return fullPath;\n  }\n  \n  private parseMemoryFile(parsed: any): { metadata: MemoryMetadata; content: string } {\n    // Extract metadata with validation\n    const metadata: MemoryMetadata = {\n      name: sanitizeInput(parsed.metadata?.name || 'Unnamed Memory', 100),\n      description: parsed.metadata?.description ? \n        sanitizeInput(parsed.metadata.description, 500) : \n        '',\n      version: parsed.metadata?.version || '1.0.0',\n      author: parsed.metadata?.author,\n      created: parsed.metadata?.created,\n      modified: new Date().toISOString(),\n      tags: Array.isArray(parsed.metadata?.tags) ? \n        parsed.metadata.tags.map((tag: string) => sanitizeInput(tag, 50)) : \n        [],\n      storageBackend: parsed.metadata?.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND,\n      retentionDays: parsed.metadata?.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS,\n      privacyLevel: parsed.metadata?.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL,\n      searchable: parsed.metadata?.searchable !== false,\n      maxEntries: parsed.metadata?.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT\n    };\n    \n    // Extract content (if any)\n    const content = parsed.content || '';\n    \n    return { metadata, content };\n  }\n}"]}

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

@@ -0,0 +1,42 @@
+/**
+ * Constants for Memory element implementation
+ * Extracted for reusability and maintainability
+ */
+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;
+    readonly MAX_YAML_SIZE: number;
+    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";
+};
+//# 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;;;GAGG;AAGH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;CA+BnB,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;;;;;;;;;;;;;;;CAezB,CAAC"}

package/dist/elements/memories/constants.js

@@ -0,0 +1,49 @@
+/**
+ * Constants for Memory element implementation
+ * Extracted for reusability and maintainability
+ */
+// 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 limits
+    MAX_YAML_SIZE: 256 * 1024, // 256KB max YAML size for import
+    // Privacy levels (ordered by access level)
+    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',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VsZW1lbnRzL21lbW9yaWVzL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxxQkFBcUI7QUFDckIsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUc7SUFDOUIsY0FBYztJQUNkLGVBQWUsRUFBRSxJQUFJLEdBQUcsSUFBSSxFQUFTLHdCQUF3QjtJQUM3RCxjQUFjLEVBQUUsR0FBRyxHQUFHLElBQUksRUFBVyxrQkFBa0I7SUFDdkQsbUJBQW1CLEVBQUUsSUFBSSxFQUFZLDRCQUE0QjtJQUVqRSxlQUFlO0lBQ2Ysa0JBQWtCLEVBQUUsRUFBRSxFQUFlLGdDQUFnQztJQUNyRSxjQUFjLEVBQUUsRUFBRSxFQUFtQiw2QkFBNkI7SUFDbEUsaUJBQWlCLEVBQUUsRUFBRSxFQUFnQixrQ0FBa0M7SUFDdkUsdUJBQXVCLEVBQUUsRUFBRSxFQUFVLDhCQUE4QjtJQUNuRSx5QkFBeUIsRUFBRSxHQUFHLEVBQU8sZ0NBQWdDO0lBRXJFLHFCQUFxQjtJQUNyQixzQkFBc0IsRUFBRSxFQUFFLEVBQVcsMkJBQTJCO0lBQ2hFLGtCQUFrQixFQUFFLENBQUMsRUFBZ0IsMkJBQTJCO0lBQ2hFLGtCQUFrQixFQUFFLEdBQUcsRUFBYywyQkFBMkI7SUFFaEUsZ0JBQWdCO0lBQ2hCLG9CQUFvQixFQUFFLEdBQUcsRUFBWSw4QkFBOEI7SUFFbkUsY0FBYztJQUNkLGFBQWEsRUFBRSxHQUFHLEdBQUcsSUFBSSxFQUFZLGlDQUFpQztJQUV0RSwyQ0FBMkM7SUFDM0MsY0FBYyxFQUFFLENBQUMsUUFBUSxFQUFFLFNBQVMsRUFBRSxXQUFXLENBQVU7SUFDM0QscUJBQXFCLEVBQUUsU0FBa0I7SUFFekMsbUJBQW1CO0lBQ25CLHVCQUF1QixFQUFFLFFBQWlCO0lBQzFDLDBCQUEwQixFQUFFLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxTQUFTLENBQVU7Q0FDMUQsQ0FBQztBQU1YLDZDQUE2QztBQUM3QyxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRztJQUNwQyxjQUFjLEVBQUUsZ0JBQWdCO0lBQ2hDLFlBQVksRUFBRSxjQUFjO0lBQzVCLGVBQWUsRUFBRSxpQkFBaUI7SUFDbEMsd0JBQXdCLEVBQUUsMEJBQTBCO0lBQ3BELHlCQUF5QixFQUFFLDJCQUEyQjtJQUN0RCxjQUFjLEVBQUUsZ0JBQWdCO0lBQ2hDLGFBQWEsRUFBRSxlQUFlO0lBQzlCLFlBQVksRUFBRSxjQUFjO0lBQzVCLGNBQWMsRUFBRSxnQkFBZ0I7SUFDaEMsa0JBQWtCLEVBQUUsb0JBQW9CO0lBQ3hDLGtCQUFrQixFQUFFLG9CQUFvQjtJQUN4Qyx5QkFBeUIsRUFBRSwyQkFBMkI7SUFDdEQsdUJBQXVCLEVBQUUseUJBQXlCO0lBQ2xELG9CQUFvQixFQUFFLHNCQUFzQjtDQUNwQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb25zdGFudHMgZm9yIE1lbW9yeSBlbGVtZW50IGltcGxlbWVudGF0aW9uXG4gKiBFeHRyYWN0ZWQgZm9yIHJldXNhYmlsaXR5IGFuZCBtYWludGFpbmFiaWxpdHlcbiAqL1xuXG4vLyBNZW1vcnkgc2l6ZSBsaW1pdHNcbmV4cG9ydCBjb25zdCBNRU1PUllfQ09OU1RBTlRTID0ge1xuICAvLyBTaXplIGxpbWl0c1xuICBNQVhfTUVNT1JZX1NJWkU6IDEwMjQgKiAxMDI0LCAgICAgICAgLy8gMU1CIHRvdGFsIG1lbW9yeSBzaXplXG4gIE1BWF9FTlRSWV9TSVpFOiAxMDAgKiAxMDI0LCAgICAgICAgICAvLyAxMDBLQiBwZXIgZW50cnlcbiAgTUFYX0VOVFJJRVNfREVGQVVMVDogMTAwMCwgICAgICAgICAgIC8vIE1heGltdW0gbnVtYmVyIG9mIGVudHJpZXNcbiAgXG4gIC8vIEVudHJ5IGxpbWl0c1xuICBNQVhfVEFHU19QRVJfRU5UUlk6IDIwLCAgICAgICAgICAgICAgLy8gTWF4aW11bSB0YWdzIHBlciBtZW1vcnkgZW50cnlcbiAgTUFYX1RBR19MRU5HVEg6IDUwLCAgICAgICAgICAgICAgICAgIC8vIE1heGltdW0gbGVuZ3RoIG9mIGVhY2ggdGFnXG4gIE1BWF9NRVRBREFUQV9LRVlTOiAyMCwgICAgICAgICAgICAgICAvLyBNYXhpbXVtIG1ldGFkYXRhIGtleXMgcGVyIGVudHJ5XG4gIE1BWF9NRVRBREFUQV9LRVlfTEVOR1RIOiA1MCwgICAgICAgICAvLyBNYXhpbXVtIG1ldGFkYXRhIGtleSBsZW5ndGhcbiAgTUFYX01FVEFEQVRBX1ZBTFVFX0xFTkdUSDogMjAwLCAgICAgIC8vIE1heGltdW0gbWV0YWRhdGEgdmFsdWUgbGVuZ3RoXG4gIFxuICAvLyBSZXRlbnRpb24gZGVmYXVsdHNcbiAgREVGQVVMVF9SRVRFTlRJT05fREFZUzogMzAsICAgICAgICAgIC8vIERlZmF1bHQgcmV0ZW50aW9uIHBlcmlvZFxuICBNSU5fUkVURU5USU9OX0RBWVM6IDEsICAgICAgICAgICAgICAgLy8gTWluaW11bSByZXRlbnRpb24gcGVyaW9kXG4gIE1BWF9SRVRFTlRJT05fREFZUzogMzY1LCAgICAgICAgICAgICAvLyBNYXhpbXVtIHJldGVudGlvbiBwZXJpb2RcbiAgXG4gIC8vIFNlYXJjaCBsaW1pdHNcbiAgREVGQVVMVF9TRUFSQ0hfTElNSVQ6IDEwMCwgICAgICAgICAgIC8vIERlZmF1bHQgc2VhcmNoIHJlc3VsdCBsaW1pdFxuICBcbiAgLy8gWUFNTCBsaW1pdHNcbiAgTUFYX1lBTUxfU0laRTogMjU2ICogMTAyNCwgICAgICAgICAgIC8vIDI1NktCIG1heCBZQU1MIHNpemUgZm9yIGltcG9ydFxuICBcbiAgLy8gUHJpdmFjeSBsZXZlbHMgKG9yZGVyZWQgYnkgYWNjZXNzIGxldmVsKVxuICBQUklWQUNZX0xFVkVMUzogWydwdWJsaWMnLCAncHJpdmF0ZScsICdzZW5zaXRpdmUnXSBhcyBjb25zdCxcbiAgREVGQVVMVF9QUklWQUNZX0xFVkVMOiAncHJpdmF0ZScgYXMgY29uc3QsXG4gIFxuICAvLyBTdG9yYWdlIGJhY2tlbmRzXG4gIERFRkFVTFRfU1RPUkFHRV9CQUNLRU5EOiAnbWVtb3J5JyBhcyBjb25zdCxcbiAgU1VQUE9SVEVEX1NUT1JBR0VfQkFDS0VORFM6IFsnbWVtb3J5JywgJ2ZpbGUnLCAnaW5kZXhlZCddIGFzIGNvbnN0LFxufSBhcyBjb25zdDtcblxuLy8gVHlwZSBleHBvcnRzIGZvciBwcml2YWN5IGxldmVscyBhbmQgc3RvcmFnZSBiYWNrZW5kc1xuZXhwb3J0IHR5cGUgUHJpdmFjeUxldmVsID0gdHlwZW9mIE1FTU9SWV9DT05TVEFOVFMuUFJJVkFDWV9MRVZFTFNbbnVtYmVyXTtcbmV4cG9ydCB0eXBlIFN0b3JhZ2VCYWNrZW5kID0gdHlwZW9mIE1FTU9SWV9DT05TVEFOVFMuU1VQUE9SVEVEX1NUT1JBR0VfQkFDS0VORFNbbnVtYmVyXTtcblxuLy8gU2VjdXJpdHkgZXZlbnQgdHlwZXMgZm9yIG1lbW9yeSBvcGVyYXRpb25zXG5leHBvcnQgY29uc3QgTUVNT1JZX1NFQ1VSSVRZX0VWRU5UUyA9IHtcbiAgTUVNT1JZX0NSRUFURUQ6ICdNRU1PUllfQ1JFQVRFRCcsXG4gIE1FTU9SWV9BRERFRDogJ01FTU9SWV9BRERFRCcsXG4gIE1FTU9SWV9TRUFSQ0hFRDogJ01FTU9SWV9TRUFSQ0hFRCcsXG4gIFNFTlNJVElWRV9NRU1PUllfREVMRVRFRDogJ1NFTlNJVElWRV9NRU1PUllfREVMRVRFRCcsXG4gIFJFVEVOVElPTl9QT0xJQ1lfRU5GT1JDRUQ6ICdSRVRFTlRJT05fUE9MSUNZX0VORk9SQ0VEJyxcbiAgTUVNT1JZX0NMRUFSRUQ6ICdNRU1PUllfQ0xFQVJFRCcsXG4gIE1FTU9SWV9MT0FERUQ6ICdNRU1PUllfTE9BREVEJyxcbiAgTUVNT1JZX1NBVkVEOiAnTUVNT1JZX1NBVkVEJyxcbiAgTUVNT1JZX0RFTEVURUQ6ICdNRU1PUllfREVMRVRFRCcsXG4gIE1FTU9SWV9MT0FEX0ZBSUxFRDogJ01FTU9SWV9MT0FEX0ZBSUxFRCcsXG4gIE1FTU9SWV9TQVZFX0ZBSUxFRDogJ01FTU9SWV9TQVZFX0ZBSUxFRCcsXG4gIE1FTU9SWV9ERVNFUklBTElaRV9GQUlMRUQ6ICdNRU1PUllfREVTRVJJQUxJWkVfRkFJTEVEJyxcbiAgTUVNT1JZX0xJU1RfSVRFTV9GQUlMRUQ6ICdNRU1PUllfTElTVF9JVEVNX0ZBSUxFRCcsXG4gIE1FTU9SWV9JTVBPUlRfRkFJTEVEOiAnTUVNT1JZX0lNUE9SVF9GQUlMRUQnLFxufSBhcyBjb25zdDsiXX0=

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

@@ -0,0 +1,6 @@
+/**
+ * Memory element exports
+ */
+export { Memory, MemoryMetadata, MemoryEntry, MemorySearchOptions } from './Memory.js';
+export { MemoryManager } from './MemoryManager.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"}

package/dist/elements/memories/index.js

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