dartmind 17.0.0

package/dist/jarvis/memory/MemoryManager.js

@@ -0,0 +1,759 @@
+/**
+ * MemoryManager - Unified memory system for JARVIS
+ *
+ * Manages four memory layers:
+ * 1. Session Memory - Current conversation context
+ * 2. Project Memory - Project-specific learnings
+ * 3. User Memory - Global user preferences
+ * 4. Relationship Memory - User-JARVIS relationship tracking
+ *
+ * Features:
+ * - Automatic persistence to ~/.flutterai/memory/
+ * - Memory summarization and compaction
+ * - Semantic search via embeddings (when available)
+ * - Cross-memory queries
+ */
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createSession, } from './schemas/session.schema.js';
+import { createProjectMemory, PROJECT_SCHEMA_VERSION, } from './schemas/project.schema.js';
+import { createUserMemory, USER_SCHEMA_VERSION, } from './schemas/user.schema.js';
+import { createRelationshipMemory, calculateRelationshipStage, updateTrustLevel, RELATIONSHIP_SCHEMA_VERSION, } from './schemas/relationship.schema.js';
+export class MemoryManager extends EventEmitter {
+    static instance;
+    config;
+    session = null;
+    project = null;
+    user = null;
+    relationship = null;
+    autoSaveTimer = null;
+    dirty = new Set();
+    constructor(config) {
+        super();
+        this.config = {
+            baseDir: path.join(os.homedir(), '.flutterai', 'memory'),
+            autoSaveInterval: 30000, // 30 seconds
+            maxSessionHistory: 100,
+            enableEmbeddings: false,
+            ...config,
+        };
+        this.ensureDirectories();
+    }
+    static getInstance(config) {
+        if (!MemoryManager.instance) {
+            MemoryManager.instance = new MemoryManager(config);
+        }
+        return MemoryManager.instance;
+    }
+    static resetInstance() {
+        if (MemoryManager.instance) {
+            MemoryManager.instance.shutdown();
+            MemoryManager.instance = null;
+        }
+    }
+    /**
+     * Initialize memory system for a new session
+     */
+    async initialize(workingDirectory) {
+        // Load or create user memory
+        this.user = await this.loadUserMemory();
+        // Load or create relationship memory
+        this.relationship = await this.loadRelationshipMemory(this.user.userId);
+        // Create new session
+        const projectId = this.hashPath(workingDirectory);
+        this.session = createSession(workingDirectory, projectId);
+        // Load project memory if exists
+        this.project = await this.loadProjectMemory(projectId, workingDirectory);
+        // Update relationship
+        this.relationship.totalSessions++;
+        this.relationship.stage = calculateRelationshipStage(this.relationship);
+        this.markDirty('relationship');
+        // Update user
+        this.user.lastActiveAt = Date.now();
+        this.user.totalInteractions++;
+        this.markDirty('user');
+        // Update project
+        if (this.project) {
+            this.project.lastAccessedAt = Date.now();
+            this.project.sessionCount++;
+            this.markDirty('project');
+        }
+        // Start auto-save
+        this.startAutoSave();
+        this.emit('initialized', this.getContext());
+        return this.getContext();
+    }
+    /**
+     * Get current memory context
+     */
+    getContext() {
+        if (!this.session || !this.user || !this.relationship) {
+            throw new Error('Memory not initialized. Call initialize() first.');
+        }
+        return {
+            session: this.session,
+            project: this.project ?? undefined,
+            user: this.user,
+            relationship: this.relationship,
+        };
+    }
+    /**
+     * Update session memory
+     */
+    updateSession(updates) {
+        if (!this.session)
+            return;
+        Object.assign(this.session, updates);
+        this.session.lastActivityAt = Date.now();
+        this.markDirty('session');
+        this.emit('session:updated', this.session);
+    }
+    /**
+     * Record a file touch
+     */
+    recordFileTouch(filePath, action, description) {
+        if (!this.session)
+            return;
+        const existing = this.session.touchedFiles.find(f => f.path === filePath);
+        if (existing) {
+            existing.action = action;
+            existing.timestamp = Date.now();
+            existing.accessCount++;
+            if (description)
+                existing.description = description;
+        }
+        else {
+            this.session.touchedFiles.push({
+                path: filePath,
+                action,
+                timestamp: Date.now(),
+                description,
+                accessCount: 1,
+            });
+        }
+        this.markDirty('session');
+    }
+    /**
+     * Record a command execution
+     */
+    recordCommand(command, description, exitCode, duration) {
+        if (!this.session)
+            return;
+        this.session.commandHistory.push({
+            command,
+            description,
+            exitCode,
+            success: exitCode === 0,
+            timestamp: Date.now(),
+            duration,
+        });
+        // Keep history manageable
+        if (this.session.commandHistory.length > this.config.maxSessionHistory) {
+            this.session.commandHistory = this.session.commandHistory.slice(-this.config.maxSessionHistory);
+        }
+        this.markDirty('session');
+    }
+    /**
+     * Record a detected signal
+     */
+    recordSignal(type, value, confidence, source) {
+        if (!this.session)
+            return;
+        this.session.detectedSignals.push({
+            type,
+            value,
+            confidence,
+            source,
+            timestamp: Date.now(),
+        });
+        this.markDirty('session');
+        this.emit('signal:detected', { type, value, confidence, source });
+    }
+    /**
+     * Update project patterns
+     */
+    updateProjectPatterns(patterns) {
+        if (!this.project)
+            return;
+        this.project.patterns = {
+            ...this.project.patterns,
+            ...patterns,
+        };
+        this.markDirty('project');
+    }
+    /**
+     * Add file knowledge
+     */
+    addFileKnowledge(knowledge) {
+        if (!this.project)
+            return;
+        const existing = this.project.fileKnowledge.findIndex(f => f.path === knowledge.path);
+        if (existing !== -1) {
+            this.project.fileKnowledge[existing] = knowledge;
+        }
+        else {
+            this.project.fileKnowledge.push(knowledge);
+        }
+        this.markDirty('project');
+    }
+    /**
+     * Record a known issue
+     */
+    recordKnownIssue(issue) {
+        if (!this.project)
+            return;
+        const id = `issue-${Date.now().toString(36)}`;
+        this.project.knownIssues.push({ id, ...issue });
+        this.markDirty('project');
+    }
+    /**
+     * Update user preferences
+     */
+    updateUserPreferences(prefs) {
+        if (!this.user)
+            return;
+        Object.assign(this.user, prefs);
+        this.markDirty('user');
+    }
+    /**
+     * Record learned behavior
+     */
+    recordLearnedBehavior(behavior, category, context) {
+        if (!this.user)
+            return;
+        const existing = this.user.learnedBehaviors.find(b => b.behavior === behavior && b.category === category);
+        if (existing) {
+            existing.observationCount++;
+            existing.lastObserved = Date.now();
+            existing.confidence = Math.min(1, existing.confidence + 0.1);
+        }
+        else {
+            this.user.learnedBehaviors.push({
+                id: `behavior-${Date.now().toString(36)}`,
+                behavior,
+                category,
+                confidence: 0.5,
+                observationCount: 1,
+                firstObserved: Date.now(),
+                lastObserved: Date.now(),
+                sourceContext: context,
+                active: true,
+            });
+        }
+        this.markDirty('user');
+    }
+    /**
+     * Record relationship event
+     */
+    recordRelationshipEvent(event, description, magnitude = 0.5) {
+        if (!this.relationship)
+            return;
+        this.relationship.trustLevel = updateTrustLevel(this.relationship.trustLevel, event, magnitude);
+        if (event === 'success' || event === 'resolution') {
+            this.relationship.positiveMoments.push({
+                id: `moment-${Date.now().toString(36)}`,
+                description,
+                category: event === 'success' ? 'success' : 'learning',
+                occurredAt: Date.now(),
+                rapportImpact: 0.02 * magnitude,
+            });
+            this.relationship.rapportScore = Math.min(1, this.relationship.rapportScore + 0.02 * magnitude);
+        }
+        if (event === 'conflict' || event === 'failure') {
+            this.relationship.conflictHistory.push({
+                id: `conflict-${Date.now().toString(36)}`,
+                description,
+                category: event === 'conflict' ? 'frustration' : 'error',
+                severity: magnitude,
+                occurredAt: Date.now(),
+                resolved: event === 'failure', // Failures are "resolved" implicitly
+                lessons: [],
+                trustImpact: -0.05 * magnitude,
+            });
+        }
+        this.relationship.stage = calculateRelationshipStage(this.relationship);
+        this.markDirty('relationship');
+    }
+    /**
+     * Search across memories
+     */
+    async search(query) {
+        const results = [];
+        const types = query.types ?? ['session', 'project', 'user', 'relationship'];
+        const limit = query.limit ?? 10;
+        // Use semantic search if enabled, otherwise fall back to keyword search
+        const keywords = query.text.toLowerCase().split(/\s+/);
+        const queryVector = this.config.enableEmbeddings
+            ? this.computeTFIDFVector(keywords)
+            : null;
+        if (types.includes('session') && this.session) {
+            results.push(...this.searchSession(keywords));
+        }
+        if (types.includes('project') && this.project) {
+            results.push(...this.searchProject(keywords));
+        }
+        if (types.includes('user') && this.user) {
+            results.push(...this.searchUser(keywords));
+        }
+        if (types.includes('relationship') && this.relationship) {
+            results.push(...this.searchRelationship(keywords));
+        }
+        // Sort by score and limit
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .filter(r => r.score >= (query.minScore ?? 0));
+    }
+    /**
+     * End current session
+     */
+    async endSession(summary) {
+        if (!this.session)
+            return;
+        // Create session summary for project memory
+        if (this.project && summary) {
+            this.project.sessionSummaries.push({
+                sessionId: this.session.sessionId,
+                timestamp: this.session.startedAt,
+                duration: Date.now() - this.session.startedAt,
+                summary,
+                changes: this.session.touchedFiles
+                    .filter(f => f.action !== 'read')
+                    .map(f => `${f.action}: ${f.path}`),
+                lessons: [],
+                filesModified: this.session.touchedFiles
+                    .filter(f => f.action !== 'read')
+                    .map(f => f.path),
+            });
+            // Keep only recent summaries
+            if (this.project.sessionSummaries.length > 50) {
+                this.project.sessionSummaries = this.project.sessionSummaries.slice(-50);
+            }
+            this.markDirty('project');
+        }
+        // Update relationship
+        if (this.relationship) {
+            this.relationship.totalInteractionTime += Date.now() - this.session.startedAt;
+            this.markDirty('relationship');
+        }
+        // Save all dirty memories
+        await this.saveAll();
+        // Clear session
+        this.session = null;
+        this.emit('session:ended');
+    }
+    /**
+     * Save all dirty memories
+     */
+    async saveAll() {
+        const saves = [];
+        if (this.dirty.has('session') && this.session) {
+            // Session is typically not persisted between sessions
+            // but we can save it for crash recovery
+            this.dirty.delete('session');
+        }
+        if (this.dirty.has('project') && this.project) {
+            saves.push(this.saveProjectMemory());
+            this.dirty.delete('project');
+        }
+        if (this.dirty.has('user') && this.user) {
+            saves.push(this.saveUserMemory());
+            this.dirty.delete('user');
+        }
+        if (this.dirty.has('relationship') && this.relationship) {
+            saves.push(this.saveRelationshipMemory());
+            this.dirty.delete('relationship');
+        }
+        await Promise.all(saves);
+        this.emit('saved');
+    }
+    /**
+     * Shutdown memory manager
+     */
+    shutdown() {
+        if (this.autoSaveTimer) {
+            clearInterval(this.autoSaveTimer);
+            this.autoSaveTimer = null;
+        }
+        // Synchronous save on shutdown
+        this.saveAll().catch(console.error);
+        this.emit('shutdown');
+    }
+    // Private methods
+    ensureDirectories() {
+        const dirs = [
+            this.config.baseDir,
+            path.join(this.config.baseDir, 'projects'),
+        ];
+        for (const dir of dirs) {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    markDirty(type) {
+        this.dirty.add(type);
+    }
+    startAutoSave() {
+        if (this.config.autoSaveInterval > 0 && !this.autoSaveTimer) {
+            this.autoSaveTimer = setInterval(() => {
+                if (this.dirty.size > 0) {
+                    this.saveAll().catch(console.error);
+                }
+            }, this.config.autoSaveInterval);
+        }
+    }
+    hashPath(filePath) {
+        let hash = 0;
+        for (let i = 0; i < filePath.length; i++) {
+            const char = filePath.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return `proj-${Math.abs(hash).toString(36)}`;
+    }
+    // Load methods
+    async loadUserMemory() {
+        const filePath = path.join(this.config.baseDir, 'user.json');
+        if (fs.existsSync(filePath)) {
+            try {
+                let data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                // Apply schema migrations if version differs
+                if (this.needsMigration(data.schemaVersion, USER_SCHEMA_VERSION)) {
+                    data = this.migrateUserMemory(data);
+                    data.schemaVersion = USER_SCHEMA_VERSION;
+                    // Save migrated data
+                    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+                    this.emit('memory:migrated', { type: 'user', version: USER_SCHEMA_VERSION });
+                }
+                return data;
+            }
+            catch {
+                // Corrupted file, create new
+            }
+        }
+        return createUserMemory();
+    }
+    async loadRelationshipMemory(userId) {
+        const filePath = path.join(this.config.baseDir, 'relationship.json');
+        if (fs.existsSync(filePath)) {
+            try {
+                let data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                // Apply schema migrations if version differs
+                if (this.needsMigration(data.schemaVersion, RELATIONSHIP_SCHEMA_VERSION)) {
+                    data = this.migrateRelationshipMemory(data);
+                    data.schemaVersion = RELATIONSHIP_SCHEMA_VERSION;
+                    // Save migrated data
+                    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+                    this.emit('memory:migrated', { type: 'relationship', version: RELATIONSHIP_SCHEMA_VERSION });
+                }
+                return data;
+            }
+            catch {
+                // Corrupted file, create new
+            }
+        }
+        return createRelationshipMemory(userId);
+    }
+    async loadProjectMemory(projectId, projectPath) {
+        const filePath = path.join(this.config.baseDir, 'projects', `${projectId}.json`);
+        if (fs.existsSync(filePath)) {
+            try {
+                let data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                // Apply schema migrations if version differs
+                if (this.needsMigration(data.schemaVersion, PROJECT_SCHEMA_VERSION)) {
+                    data = this.migrateProjectMemory(data);
+                    data.schemaVersion = PROJECT_SCHEMA_VERSION;
+                    // Save migrated data
+                    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+                    this.emit('memory:migrated', { type: 'project', version: PROJECT_SCHEMA_VERSION });
+                }
+                return data;
+            }
+            catch {
+                // Corrupted file, create new
+            }
+        }
+        // Create new project memory
+        const projectName = path.basename(projectPath);
+        return createProjectMemory(projectPath, projectName);
+    }
+    // Save methods
+    async saveProjectMemory() {
+        if (!this.project)
+            return;
+        const filePath = path.join(this.config.baseDir, 'projects', `${this.project.projectId}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(this.project, null, 2));
+    }
+    async saveUserMemory() {
+        if (!this.user)
+            return;
+        const filePath = path.join(this.config.baseDir, 'user.json');
+        fs.writeFileSync(filePath, JSON.stringify(this.user, null, 2));
+    }
+    async saveRelationshipMemory() {
+        if (!this.relationship)
+            return;
+        const filePath = path.join(this.config.baseDir, 'relationship.json');
+        fs.writeFileSync(filePath, JSON.stringify(this.relationship, null, 2));
+    }
+    // Search methods
+    searchSession(keywords) {
+        const results = [];
+        if (!this.session)
+            return results;
+        // Search conversation context
+        const contextText = [
+            this.session.conversationContext.summary,
+            ...this.session.conversationContext.topics,
+            this.session.conversationContext.currentGoal ?? '',
+        ].join(' ').toLowerCase();
+        const contextScore = this.calculateKeywordScore(contextText, keywords);
+        if (contextScore > 0) {
+            results.push({
+                type: 'session',
+                content: this.session.conversationContext.summary || 'Current session context',
+                score: contextScore,
+                context: {
+                    topics: this.session.conversationContext.topics,
+                    goal: this.session.conversationContext.currentGoal,
+                },
+            });
+        }
+        return results;
+    }
+    searchProject(keywords) {
+        const results = [];
+        if (!this.project)
+            return results;
+        // Search file knowledge
+        for (const file of this.project.fileKnowledge) {
+            const text = `${file.path} ${file.purpose} ${file.exports.join(' ')}`.toLowerCase();
+            const score = this.calculateKeywordScore(text, keywords);
+            if (score > 0.3) {
+                results.push({
+                    type: 'project',
+                    content: `${file.path}: ${file.purpose}`,
+                    score,
+                    context: { exports: file.exports },
+                });
+            }
+        }
+        // Search known issues
+        for (const issue of this.project.knownIssues) {
+            const text = `${issue.description} ${issue.symptoms.join(' ')}`.toLowerCase();
+            const score = this.calculateKeywordScore(text, keywords);
+            if (score > 0.3) {
+                results.push({
+                    type: 'project',
+                    content: `Known issue: ${issue.description}`,
+                    score,
+                    context: { solution: issue.solution },
+                });
+            }
+        }
+        return results;
+    }
+    searchUser(keywords) {
+        const results = [];
+        if (!this.user)
+            return results;
+        // Search learned behaviors
+        for (const behavior of this.user.learnedBehaviors) {
+            const text = `${behavior.behavior} ${behavior.category}`.toLowerCase();
+            const score = this.calculateKeywordScore(text, keywords);
+            if (score > 0.3) {
+                results.push({
+                    type: 'user',
+                    content: `Learned: ${behavior.behavior}`,
+                    score: score * behavior.confidence,
+                    context: { category: behavior.category },
+                });
+            }
+        }
+        return results;
+    }
+    searchRelationship(keywords) {
+        const results = [];
+        if (!this.relationship)
+            return results;
+        // Search shared context
+        for (const ctx of this.relationship.sharedContext) {
+            const text = `${ctx.content} ${ctx.category}`.toLowerCase();
+            const score = this.calculateKeywordScore(text, keywords);
+            if (score > 0.3) {
+                results.push({
+                    type: 'relationship',
+                    content: ctx.content,
+                    score,
+                    context: { category: ctx.category },
+                });
+            }
+        }
+        return results;
+    }
+    calculateKeywordScore(text, keywords) {
+        let matches = 0;
+        for (const keyword of keywords) {
+            if (text.includes(keyword)) {
+                matches++;
+            }
+        }
+        return matches / keywords.length;
+    }
+    // ==========================================================================
+    // SEMANTIC SEARCH IMPLEMENTATION
+    // ==========================================================================
+    /**
+     * Compute TF-IDF vector for semantic search
+     * Uses a simple bag-of-words approach with position hashing
+     */
+    computeTFIDFVector(tokens) {
+        const vectorSize = 256; // Compact vector for local computation
+        const vector = new Array(vectorSize).fill(0);
+        // Filter common stop words
+        const stopWords = new Set([
+            'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+            'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+            'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
+            'of', 'to', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as',
+            'and', 'or', 'but', 'if', 'then', 'else', 'when', 'up', 'out',
+            'this', 'that', 'these', 'those', 'it', 'its',
+        ]);
+        const filteredTokens = tokens.filter(t => t.length > 2 && !stopWords.has(t));
+        // Compute term frequency with position weighting
+        filteredTokens.forEach((token, position) => {
+            const hash = this.hashToken(token);
+            const index = Math.abs(hash) % vectorSize;
+            // Position-weighted TF (earlier terms weighted more)
+            const positionWeight = 1 / (1 + position * 0.1);
+            vector[index] += positionWeight / filteredTokens.length;
+        });
+        // Normalize vector
+        const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+        if (magnitude > 0) {
+            for (let i = 0; i < vector.length; i++) {
+                vector[i] /= magnitude;
+            }
+        }
+        return vector;
+    }
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator > 0 ? dotProduct / denominator : 0;
+    }
+    /**
+     * Hash a token to a numeric value
+     */
+    hashToken(token) {
+        let hash = 5381;
+        for (let i = 0; i < token.length; i++) {
+            hash = ((hash << 5) + hash) ^ token.charCodeAt(i);
+        }
+        return hash;
+    }
+    /**
+     * Compute semantic score using TF-IDF vectors
+     */
+    computeSemanticScore(text, queryVector) {
+        const tokens = text.toLowerCase().split(/\s+/).filter(t => t.length > 2);
+        const textVector = this.computeTFIDFVector(tokens);
+        return this.cosineSimilarity(queryVector, textVector);
+    }
+    // ==========================================================================
+    // SCHEMA MIGRATION
+    // ==========================================================================
+    /**
+     * Check if migration is needed based on semver comparison
+     */
+    needsMigration(currentVersion, targetVersion) {
+        if (!currentVersion)
+            return true;
+        // Simple semver comparison - major.minor.patch
+        const current = currentVersion.split('.').map(Number);
+        const target = targetVersion.split('.').map(Number);
+        for (let i = 0; i < 3; i++) {
+            if ((current[i] || 0) < (target[i] || 0))
+                return true;
+            if ((current[i] || 0) > (target[i] || 0))
+                return false;
+        }
+        return false;
+    }
+    /**
+     * Migrate user memory to current schema
+     * Adds missing fields with default values
+     */
+    migrateUserMemory(data) {
+        // Ensure all required arrays exist
+        if (!data.learnedBehaviors)
+            data.learnedBehaviors = [];
+        if (!data.feedbackHistory)
+            data.feedbackHistory = [];
+        if (!data.expertise)
+            data.expertise = [];
+        if (!data.shortcuts)
+            data.shortcuts = [];
+        this.emit('migration:applied', { type: 'user', version: USER_SCHEMA_VERSION });
+        return data;
+    }
+    /**
+     * Migrate project memory to current schema
+     */
+    migrateProjectMemory(data) {
+        // Ensure all required arrays exist
+        if (!data.sessionSummaries)
+            data.sessionSummaries = [];
+        if (!data.fileKnowledge)
+            data.fileKnowledge = [];
+        if (!data.knownIssues)
+            data.knownIssues = [];
+        if (!data.frequentTasks)
+            data.frequentTasks = [];
+        if (!data.vocabulary)
+            data.vocabulary = [];
+        if (!data.architectureNotes)
+            data.architectureNotes = [];
+        if (!data.embeddings)
+            data.embeddings = [];
+        this.emit('migration:applied', { type: 'project', version: PROJECT_SCHEMA_VERSION });
+        return data;
+    }
+    /**
+     * Migrate relationship memory to current schema
+     */
+    migrateRelationshipMemory(data) {
+        // Ensure all required arrays exist
+        if (!data.sharedContext)
+            data.sharedContext = [];
+        if (!data.conflictHistory)
+            data.conflictHistory = [];
+        if (!data.positiveMoments)
+            data.positiveMoments = [];
+        if (!data.milestones)
+            data.milestones = [];
+        if (!data.adaptationHistory)
+            data.adaptationHistory = [];
+        this.emit('migration:applied', { type: 'relationship', version: RELATIONSHIP_SCHEMA_VERSION });
+        return data;
+    }
+}
+// Export singleton getter
+export const getMemoryManager = MemoryManager.getInstance;
+export default MemoryManager;
+//# sourceMappingURL=MemoryManager.js.map