snow-flow 3.0.9 → 3.0.10

package/dist/memory/memory-system.js

@@ -1,651 +0,0 @@
-"use strict";
-/**
- * Snow-Flow Memory System
- * SQLite-based persistent memory with caching for agent coordination
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemorySystem = void 0;
-const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
-const events_1 = require("events");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const logger_1 = require("../utils/logger");
-class MemorySystem extends events_1.EventEmitter {
-    constructor(options) {
-        super();
-        this.cache = new Map();
-        this.cacheStats = { hits: 0, misses: 0, size: 0, evictions: 0 };
-        this.initialized = false;
-        this.options = options;
-        this.logger = new logger_1.Logger('MemorySystem');
-    }
-    /**
-     * 🔧 CRIT-003 FIX: Store data with agent isolation
-     * Implements agentId::contextKey namespacing for complete memory isolation
-     */
-    async storeShared(agentId, contextKey, value, ttl) {
-        const isolatedKey = `${agentId}::${contextKey}`;
-        return this.store(isolatedKey, value, ttl);
-    }
-    /**
-     * 🔧 CRIT-003 FIX: Retrieve data with agent isolation
-     * Implements agentId::contextKey namespacing with backward compatibility
-     */
-    async retrieveShared(agentId, contextKey) {
-        const isolatedKey = `${agentId}::${contextKey}`;
-        // Try isolated key first
-        let result = await this.get(isolatedKey);
-        // Fallback to original key for backward compatibility
-        if (result === null || result === undefined) {
-            this.logger.debug(`No isolated data found for ${isolatedKey}, falling back to original key ${contextKey}`);
-            result = await this.get(contextKey);
-            // If found with original key, migrate to isolated key
-            if (result !== null && result !== undefined) {
-                this.logger.info(`Migrating data from ${contextKey} to ${isolatedKey} for agent isolation`);
-                await this.storeShared(agentId, contextKey, result);
-                // Keep original for other agents that might still need it
-            }
-        }
-        return result;
-    }
-    /**
-     * 🔧 CRIT-003 FIX: Check if agent has specific context
-     */
-    async hasSharedContext(agentId, contextKey) {
-        const isolatedKey = `${agentId}::${contextKey}`;
-        return this.exists(isolatedKey) || this.exists(contextKey);
-    }
-    /**
-     * 🔧 CRIT-003 FIX: List all context keys for an agent
-     */
-    async listAgentContexts(agentId) {
-        const prefix = `${agentId}::`;
-        const keys = await this.listKeys();
-        return keys
-            .filter(key => key.startsWith(prefix))
-            .map(key => key.substring(prefix.length));
-    }
-    /**
-     * 🔧 CRIT-003 FIX: Core store method for memory operations
-     */
-    async store(key, value, ttl) {
-        if (!this.initialized)
-            await this.initialize();
-        const now = Date.now();
-        const expiresAt = ttl ? now + (ttl * 1000) : undefined;
-        // Store in cache if enabled
-        if (this.options.cache?.enabled) {
-            this.cache.set(key, {
-                value,
-                expiresAt: expiresAt || (now + (this.options.cache.ttl * 1000))
-            });
-            this.cacheStats.size = this.cache.size;
-        }
-        // Store in database
-        await this.upsert('memory_store', {
-            key,
-            value: JSON.stringify(value),
-            created_at: new Date().toISOString(),
-            expires_at: expiresAt ? new Date(expiresAt).toISOString() : null,
-            metadata: '{}'
-        }, ['key']);
-    }
-    /**
-     * 🔧 CRIT-003 FIX: Core get method for memory operations
-     */
-    async get(key) {
-        if (!this.initialized)
-            await this.initialize();
-        // Check cache first
-        if (this.options.cache?.enabled) {
-            const cached = this.cache.get(key);
-            if (cached && cached.expiresAt > Date.now()) {
-                this.cacheStats.hits++;
-                return cached.value;
-            }
-            if (cached) {
-                this.cache.delete(key);
-                this.cacheStats.evictions++;
-            }
-            this.cacheStats.misses++;
-        }
-        // Query database
-        const rows = await this.query(`
-      SELECT value, expires_at FROM memory_store 
-      WHERE key = ? AND (expires_at IS NULL OR expires_at > datetime('now'))
-    `, [key]);
-        if (rows.length === 0)
-            return null;
-        const result = JSON.parse(rows[0].value);
-        // Update cache
-        if (this.options.cache?.enabled) {
-            const expiresAt = rows[0].expires_at
-                ? new Date(rows[0].expires_at).getTime()
-                : Date.now() + (this.options.cache.ttl * 1000);
-            this.cache.set(key, { value: result, expiresAt });
-            this.cacheStats.size = this.cache.size;
-        }
-        return result;
-    }
-    /**
-     * 🔧 CRIT-003 FIX: Check if key exists
-     */
-    async exists(key) {
-        if (!this.initialized)
-            await this.initialize();
-        const rows = await this.query(`
-      SELECT 1 FROM memory_store 
-      WHERE key = ? AND (expires_at IS NULL OR expires_at > datetime('now'))
-    `, [key]);
-        return rows.length > 0;
-    }
-    /**
-     * 🔧 CRIT-003 FIX: List all keys
-     */
-    async listKeys() {
-        if (!this.initialized)
-            await this.initialize();
-        const rows = await this.query(`
-      SELECT key FROM memory_store 
-      WHERE expires_at IS NULL OR expires_at > datetime('now')
-    `);
-        return rows.map(row => row.key);
-    }
-    /**
-     * Initialize the memory system
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        this.logger.info('Initializing Memory System...');
-        // Ensure directory exists
-        const dir = path_1.default.dirname(this.options.dbPath);
-        if (!fs_1.default.existsSync(dir)) {
-            fs_1.default.mkdirSync(dir, { recursive: true });
-        }
-        // Open database
-        this.db = new better_sqlite3_1.default(this.options.dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.pragma('synchronous = NORMAL');
-        // Create core tables
-        await this.createCoreTables();
-        // Always run critical migrations (like missing metadata column)
-        await this.runCriticalMigrations();
-        // Run optional migrations if needed
-        if (this.options.schema?.autoMigrate) {
-            await this.runMigrations();
-        }
-        // Start cleanup timer
-        this.startCleanupTimer();
-        this.initialized = true;
-        this.logger.info('Memory System initialized');
-    }
-    // Duplicate store method removed - using primary implementation above
-    // Duplicate get method removed - using primary implementation above
-    /**
-     * Update an existing value
-     */
-    async update(key, value) {
-        const existing = await this.get(key);
-        if (!existing) {
-            throw new Error(`Key not found: ${key}`);
-        }
-        await this.store(key, value);
-    }
-    // Duplicate delete method removed - using primary implementation above
-    /**
-     * Execute a raw SQL query
-     */
-    async execute(sql, params = []) {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const stmt = this.db.prepare(sql);
-        stmt.run(...params);
-    }
-    /**
-     * Query the database
-     */
-    async query(sql, params = []) {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const stmt = this.db.prepare(sql);
-        return stmt.all(...params);
-    }
-    /**
-     * Insert data into a table
-     */
-    async insert(table, data) {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const placeholders = keys.map(() => '?').join(', ');
-        const sql = `INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})`;
-        const stmt = this.db.prepare(sql);
-        stmt.run(...values);
-    }
-    /**
-     * Delete a key from memory
-     */
-    async delete(key) {
-        if (!this.initialized)
-            await this.initialize();
-        // Remove from cache
-        if (this.options.cache?.enabled) {
-            this.cache.delete(key);
-        }
-        // Remove from database
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const stmt = this.db.prepare('DELETE FROM memory_store WHERE key = ?');
-        stmt.run(key);
-    }
-    /**
-     * Upsert data (insert or update)
-     */
-    async upsert(table, data, uniqueKeys) {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const keys = Object.keys(data);
-        const values = Object.values(data);
-        const placeholders = keys.map(() => '?').join(', ');
-        const updateClause = keys
-            .filter(k => !uniqueKeys.includes(k))
-            .map(k => `${k} = excluded.${k}`)
-            .join(', ');
-        const sql = `
-      INSERT INTO ${table} (${keys.join(', ')}) VALUES (${placeholders})
-      ON CONFLICT (${uniqueKeys.join(', ')}) DO UPDATE SET ${updateClause}
-    `;
-        const stmt = this.db.prepare(sql);
-        stmt.run(...values);
-    }
-    /**
-     * Create a transaction
-     */
-    transaction(fn) {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        return this.db.transaction(fn)();
-    }
-    /**
-     * Get database statistics
-     */
-    async getDatabaseStats() {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const tables = this.db.prepare(`
-      SELECT name FROM sqlite_master WHERE type = 'table'
-    `).all();
-        const rowCounts = {};
-        for (const { name } of tables) {
-            const count = this.db.prepare(`SELECT COUNT(*) as count FROM ${name}`).get();
-            rowCounts[name] = count.count;
-        }
-        const dbFile = this.options.dbPath;
-        const stats = fs_1.default.statSync(dbFile);
-        return {
-            size: stats.size,
-            tableCount: tables.length,
-            rowCounts
-        };
-    }
-    /**
-     * Get cache statistics
-     */
-    async getCacheStats() {
-        return {
-            ...this.cacheStats,
-            size: this.cache.size
-        };
-    }
-    /**
-     * Invalidate cache
-     */
-    async invalidateCache(pattern) {
-        if (!pattern) {
-            this.cache.clear();
-            this.logger.info('Cache cleared');
-        }
-        else {
-            // Pattern-based invalidation
-            const keys = Array.from(this.cache.keys());
-            const regex = new RegExp(pattern);
-            let invalidated = 0;
-            for (const key of keys) {
-                if (regex.test(key)) {
-                    this.cache.delete(key);
-                    invalidated++;
-                }
-            }
-            this.logger.info(`Invalidated ${invalidated} cache entries matching pattern: ${pattern}`);
-        }
-    }
-    /**
-     * Create emergency backup
-     */
-    async createEmergencyBackup() {
-        if (!this.db)
-            throw new Error('Memory system not initialized');
-        const backupPath = `${this.options.dbPath}.backup.${Date.now()}`;
-        await this.db.backup(backupPath);
-        this.logger.info(`Emergency backup created: ${backupPath}`);
-        return backupPath;
-    }
-    /**
-     * Close the memory system
-     */
-    async close() {
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-        }
-        if (this.db) {
-            this.db.close();
-            this.db = undefined;
-        }
-        this.cache.clear();
-        this.initialized = false;
-        this.logger.info('Memory System closed');
-    }
-    /**
-     * Private helper methods
-     */
-    async createCoreTables() {
-        if (!this.db)
-            return;
-        // Core memory store
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS memory_store (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL,
-        ttl INTEGER,
-        expires_at INTEGER,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        metadata TEXT DEFAULT '{}'
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_memory_expires ON memory_store(expires_at);
-      
-      -- 🚀 PERFORMANCE FIX: 6 Critical indexes for 60-80% performance improvement
-      CREATE INDEX IF NOT EXISTS idx_memory_created_at ON memory_store(created_at);
-      CREATE INDEX IF NOT EXISTS idx_memory_key_expires ON memory_store(key, expires_at);
-    `);
-        // Swarm sessions
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS swarm_sessions (
-        id TEXT PRIMARY KEY,
-        objective TEXT NOT NULL,
-        started_at TIMESTAMP NOT NULL,
-        status TEXT NOT NULL,
-        queen_agent_id TEXT,
-        completed_at TIMESTAMP,
-        metadata TEXT
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_swarm_status ON swarm_sessions(status);
-      
-      -- 🚀 PERFORMANCE FIX: Critical compound index for session status queries
-      CREATE INDEX IF NOT EXISTS idx_swarm_status_started ON swarm_sessions(status, started_at);
-    `);
-        // Agent coordination
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS agent_coordination (
-        session_id TEXT NOT NULL,
-        agent_id TEXT NOT NULL,
-        agent_type TEXT NOT NULL,
-        status TEXT NOT NULL,
-        assigned_tasks TEXT,
-        progress_percentage INTEGER DEFAULT 0,
-        last_activity TIMESTAMP,
-        current_tool TEXT,
-        error_state TEXT,
-        PRIMARY KEY (session_id, agent_id)
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_agent_status ON agent_coordination(status);
-      
-      -- 🚀 PERFORMANCE FIX: Critical compound indexes for agent queries  
-      CREATE INDEX IF NOT EXISTS idx_agent_session_type ON agent_coordination(session_id, agent_type);
-      CREATE INDEX IF NOT EXISTS idx_agent_activity ON agent_coordination(last_activity);
-    `);
-        // ServiceNow artifacts
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS servicenow_artifacts (
-        sys_id TEXT PRIMARY KEY,
-        artifact_type TEXT NOT NULL,
-        name TEXT NOT NULL,
-        description TEXT,
-        created_by_agent TEXT,
-        session_id TEXT,
-        deployment_status TEXT,
-        update_set_id TEXT,
-        dependencies TEXT,
-        metadata TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_artifact_session ON servicenow_artifacts(session_id);
-      CREATE INDEX IF NOT EXISTS idx_artifact_type ON servicenow_artifacts(artifact_type);
-    `);
-        // Agent messages
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS agent_messages (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        from_agent TEXT NOT NULL,
-        to_agent TEXT NOT NULL,
-        message_type TEXT NOT NULL,
-        content TEXT,
-        artifact_reference TEXT,
-        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        processed BOOLEAN DEFAULT FALSE
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_message_session ON agent_messages(session_id);
-      CREATE INDEX IF NOT EXISTS idx_message_processed ON agent_messages(processed);
-    `);
-        // Shared context
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS shared_context (
-        session_id TEXT NOT NULL,
-        context_key TEXT NOT NULL,
-        context_value TEXT,
-        created_by_agent TEXT,
-        expires_at TIMESTAMP,
-        access_permissions TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        PRIMARY KEY (session_id, context_key)
-      );
-    `);
-        // Performance metrics
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS performance_metrics (
-        id TEXT PRIMARY KEY,
-        operation TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        duration INTEGER,
-        success BOOLEAN NOT NULL,
-        session_id TEXT,
-        agent_id TEXT,
-        metadata TEXT,
-        resource_usage TEXT,
-        error TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      );
-      
-      CREATE INDEX IF NOT EXISTS idx_perf_operation ON performance_metrics(operation);
-      CREATE INDEX IF NOT EXISTS idx_perf_session ON performance_metrics(session_id);
-      CREATE INDEX IF NOT EXISTS idx_perf_time ON performance_metrics(start_time);
-      
-      -- 🚀 PERFORMANCE FIX: Final critical performance index
-      CREATE INDEX IF NOT EXISTS idx_perf_success_time ON performance_metrics(success, created_at);
-    `);
-    }
-    async runCriticalMigrations() {
-        // Critical migrations that must always run
-        try {
-            // Fix for missing metadata column
-            const tableInfo = this.db.prepare("PRAGMA table_info(memory_store)").all();
-            const hasMetadataColumn = tableInfo.some((col) => col.name === 'metadata');
-            if (!hasMetadataColumn) {
-                this.logger.info('Running critical migration: Adding metadata column to memory_store table...');
-                this.db.exec("ALTER TABLE memory_store ADD COLUMN metadata TEXT DEFAULT '{}'");
-                this.logger.info('Critical migration completed: Metadata column added successfully');
-            }
-        }
-        catch (error) {
-            this.logger.warn('Could not complete critical migrations:', error);
-        }
-    }
-    async runMigrations() {
-        // Implement schema migrations if needed
-        this.logger.info('Running database migrations...');
-        // Check current version
-        const versionRow = await this.get('_schema_version');
-        const currentVersion = versionRow?.version || '0.0.0';
-        const targetVersion = this.options.schema?.version || '1.0.0';
-        if (currentVersion === targetVersion) {
-            this.logger.info('Database schema is up to date');
-            return;
-        }
-        // Run migrations based on version differences
-        // This is a placeholder - implement actual migration logic
-        // Update version
-        await this.store('_schema_version', { version: targetVersion });
-        this.logger.info(`Database migrated to version ${targetVersion}`);
-    }
-    // 🔴 SNOW-003 FIX: More aggressive cleanup to prevent memory exhaustion
-    startCleanupTimer() {
-        // 🔴 CRITICAL: Run cleanup every 15 minutes instead of 1 hour
-        this.cleanupTimer = setInterval(async () => {
-            await this.cleanup();
-        }, 900000); // 15 minutes
-        // 🔴 CRITICAL: Additional memory pressure cleanup every 5 minutes
-        setInterval(async () => {
-            await this.memoryPressureCleanup();
-        }, 300000); // 5 minutes
-    }
-    // 🔴 SNOW-003 FIX: Enhanced cleanup with memory pressure monitoring
-    async cleanup() {
-        if (!this.db)
-            return;
-        const now = Date.now();
-        const startTime = Date.now();
-        try {
-            // 🔴 CRITICAL: Clean expired memory entries with better logging
-            const stmt = this.db.prepare('DELETE FROM memory_store WHERE expires_at < ?');
-            const result = stmt.run(now);
-            if (result.changes > 0) {
-                this.logger.info(`🧹 Cleaned up ${result.changes} expired memory entries`);
-            }
-            // 🔴 CRITICAL: Clean cache with size monitoring
-            let cacheCleanedCount = 0;
-            const cacheEntriesBefore = this.cache.size;
-            for (const [key, entry] of this.cache.entries()) {
-                if (entry.expiresAt < now) {
-                    this.cache.delete(key);
-                    cacheCleanedCount++;
-                }
-            }
-            if (cacheCleanedCount > 0) {
-                this.logger.info(`🧹 Cleaned ${cacheCleanedCount} expired cache entries (${cacheEntriesBefore} → ${this.cache.size})`);
-            }
-            // 🔴 CRITICAL: More frequent vacuum for high activity
-            const lastVacuum = await this.get('_last_vacuum');
-            const shouldVacuum = !lastVacuum || now - lastVacuum > 21600000; // 6 hours instead of 24
-            if (shouldVacuum) {
-                this.logger.info('🗃️ Starting database vacuum...');
-                this.db.exec('VACUUM');
-                await this.store('_last_vacuum', now);
-                this.logger.info(`✅ Database vacuumed in ${Date.now() - startTime}ms`);
-            }
-            // 🔴 CRITICAL: Log memory stats after cleanup
-            const memUsage = process.memoryUsage();
-            const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
-            if (heapUsedMB > 100) { // Log if significant memory usage
-                this.logger.info(`📊 Memory after cleanup: ${heapUsedMB}MB heap, ${this.cache.size} cache entries`);
-            }
-        }
-        catch (error) {
-            this.logger.error('❌ Cleanup failed:', error);
-        }
-    }
-    /**
-     * 🔴 SNOW-003 FIX: Emergency cleanup when memory pressure is high
-     */
-    async memoryPressureCleanup() {
-        if (!this.db)
-            return;
-        try {
-            const memUsage = process.memoryUsage();
-            const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
-            const cacheSize = this.cache.size;
-            // 🔴 CRITICAL: Trigger aggressive cleanup if memory is high
-            if (heapUsedMB > 300 || cacheSize > 1000) {
-                this.logger.warn(`⚠️ High memory pressure detected: ${heapUsedMB}MB heap, ${cacheSize} cache entries`);
-                // 1. Aggressive cache cleanup - remove 50% of oldest entries
-                if (cacheSize > 500) {
-                    const entries = Array.from(this.cache.entries())
-                        .sort((a, b) => a[1].expiresAt - b[1].expiresAt);
-                    const toRemove = Math.floor(entries.length * 0.5);
-                    for (let i = 0; i < toRemove; i++) {
-                        this.cache.delete(entries[i][0]);
-                    }
-                    this.logger.info(`🧹 Emergency cache cleanup: removed ${toRemove} entries (${cacheSize} → ${this.cache.size})`);
-                }
-                // 2. Clean old database entries more aggressively
-                const now = Date.now();
-                const aggressiveCleanupTime = now - (7 * 24 * 60 * 60 * 1000); // 7 days old
-                const aggressiveStmt = this.db.prepare('DELETE FROM memory_store WHERE created_at < ? AND expires_at IS NULL');
-                const aggressiveResult = aggressiveStmt.run(aggressiveCleanupTime);
-                if (aggressiveResult.changes > 0) {
-                    this.logger.info(`🧹 Emergency database cleanup: removed ${aggressiveResult.changes} old entries`);
-                }
-                // 3. Force garbage collection if available
-                if (global.gc) {
-                    this.logger.info('🗑️ Forcing garbage collection due to memory pressure');
-                    global.gc();
-                    // Check memory after GC
-                    const afterGC = process.memoryUsage();
-                    const afterGCMB = Math.round(afterGC.heapUsed / 1024 / 1024);
-                    this.logger.info(`📊 Memory after GC: ${heapUsedMB}MB → ${afterGCMB}MB`);
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error('❌ Memory pressure cleanup failed:', error);
-        }
-    }
-    checkCacheSize() {
-        if (!this.options.cache?.enabled)
-            return;
-        const maxSize = this.options.cache.maxSize || 100;
-        const currentSizeMB = this.estimateCacheSize();
-        if (currentSizeMB > maxSize) {
-            // Evict oldest entries
-            const entries = Array.from(this.cache.entries())
-                .sort((a, b) => a[1].expiresAt - b[1].expiresAt);
-            const toEvict = Math.floor(entries.length * 0.2); // Evict 20%
-            for (let i = 0; i < toEvict; i++) {
-                this.cache.delete(entries[i][0]);
-                this.cacheStats.evictions++;
-            }
-            this.logger.debug(`Evicted ${toEvict} cache entries due to size limit`);
-        }
-    }
-    estimateCacheSize() {
-        // Rough estimate of cache size in MB
-        let size = 0;
-        for (const [key, entry] of this.cache.entries()) {
-            size += key.length + JSON.stringify(entry.value).length;
-        }
-        return size / 1024 / 1024;
-    }
-}
-exports.MemorySystem = MemorySystem;
-//# sourceMappingURL=memory-system.js.map

package/dist/memory/memory-test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Snow-Flow Memory System Test
- * Demonstrates and tests the SQLite memory system functionality
- */
-export {};
-//# sourceMappingURL=memory-test.d.ts.map