Initial commit: Brainy - Multi-Dimensional AI Database

Open source vector database with HNSW indexing, graph relationships,
and metadata facets. Features CLI with professional augmentation registry
integration for discovering extensions and capabilities.

dist/distributed/operationalModes.js

@@ -0,0 +1,201 @@
+/**
+ * Operational Modes for Distributed Brainy
+ * Defines different modes with optimized caching strategies
+ */
+/**
+ * Base operational mode
+ */
+export class BaseOperationalMode {
+    /**
+     * Validate operation is allowed in this mode
+     */
+    validateOperation(operation) {
+        switch (operation) {
+            case 'read':
+                if (!this.canRead) {
+                    throw new Error('Read operations are not allowed in write-only mode');
+                }
+                break;
+            case 'write':
+                if (!this.canWrite) {
+                    throw new Error('Write operations are not allowed in read-only mode');
+                }
+                break;
+            case 'delete':
+                if (!this.canDelete) {
+                    throw new Error('Delete operations are not allowed in this mode');
+                }
+                break;
+        }
+    }
+}
+/**
+ * Read-only mode optimized for query performance
+ */
+export class ReaderMode extends BaseOperationalMode {
+    constructor() {
+        super(...arguments);
+        this.canRead = true;
+        this.canWrite = false;
+        this.canDelete = false;
+        this.cacheStrategy = {
+            hotCacheRatio: 0.8, // 80% of memory for read cache
+            prefetchAggressive: true, // Aggressively prefetch related vectors
+            ttl: 3600000, // 1 hour cache TTL
+            compressionEnabled: true, // Trade CPU for more cache capacity
+            writeBufferSize: 0, // No write buffer needed
+            batchWrites: false, // No writes
+            adaptive: true // Adapt to query patterns
+        };
+    }
+    /**
+     * Get optimized cache configuration for readers
+     */
+    getCacheConfig() {
+        return {
+            hotCacheMaxSize: 1000000, // Large hot cache
+            hotCacheEvictionThreshold: 0.9, // Keep cache full
+            warmCacheTTL: 3600000, // 1 hour warm cache
+            batchSize: 100, // Large batch reads
+            autoTune: true, // Auto-tune for read patterns
+            autoTuneInterval: 60000, // Tune every minute
+            readOnly: true // Enable read-only optimizations
+        };
+    }
+}
+/**
+ * Write-only mode optimized for ingestion
+ */
+export class WriterMode extends BaseOperationalMode {
+    constructor() {
+        super(...arguments);
+        this.canRead = false;
+        this.canWrite = true;
+        this.canDelete = true;
+        this.cacheStrategy = {
+            hotCacheRatio: 0.2, // Only 20% for cache, rest for write buffer
+            prefetchAggressive: false, // No prefetching needed
+            ttl: 60000, // Short TTL (1 minute)
+            compressionEnabled: false, // Speed over memory efficiency
+            writeBufferSize: 10000, // Large write buffer for batching
+            batchWrites: true, // Enable write batching
+            adaptive: false // Fixed strategy for consistent writes
+        };
+    }
+    /**
+     * Get optimized cache configuration for writers
+     */
+    getCacheConfig() {
+        return {
+            hotCacheMaxSize: 100000, // Small hot cache
+            hotCacheEvictionThreshold: 0.5, // Aggressive eviction
+            warmCacheTTL: 60000, // 1 minute warm cache
+            batchSize: 1000, // Large batch writes
+            autoTune: false, // Fixed configuration
+            writeOnly: true // Enable write-only optimizations
+        };
+    }
+}
+/**
+ * Hybrid mode that can both read and write
+ */
+export class HybridMode extends BaseOperationalMode {
+    constructor() {
+        super(...arguments);
+        this.canRead = true;
+        this.canWrite = true;
+        this.canDelete = true;
+        this.cacheStrategy = {
+            hotCacheRatio: 0.5, // Balanced cache/buffer allocation
+            prefetchAggressive: false, // Moderate prefetching
+            ttl: 600000, // 10 minute TTL
+            compressionEnabled: true, // Compress when beneficial
+            writeBufferSize: 5000, // Moderate write buffer
+            batchWrites: true, // Batch writes when possible
+            adaptive: true // Adapt to workload mix
+        };
+        this.readWriteRatio = 0.5; // Track read/write ratio
+    }
+    /**
+     * Get balanced cache configuration
+     */
+    getCacheConfig() {
+        return {
+            hotCacheMaxSize: 500000, // Medium cache size
+            hotCacheEvictionThreshold: 0.7, // Balanced eviction
+            warmCacheTTL: 600000, // 10 minute warm cache
+            batchSize: 500, // Medium batch size
+            autoTune: true, // Auto-tune based on workload
+            autoTuneInterval: 300000 // Tune every 5 minutes
+        };
+    }
+    /**
+     * Update cache strategy based on workload
+     * @param readCount - Number of recent reads
+     * @param writeCount - Number of recent writes
+     */
+    updateWorkloadBalance(readCount, writeCount) {
+        const total = readCount + writeCount;
+        if (total === 0)
+            return;
+        this.readWriteRatio = readCount / total;
+        // Adjust cache strategy based on workload
+        if (this.readWriteRatio > 0.8) {
+            // Read-heavy workload
+            this.cacheStrategy.hotCacheRatio = 0.7;
+            this.cacheStrategy.prefetchAggressive = true;
+            this.cacheStrategy.writeBufferSize = 2000;
+        }
+        else if (this.readWriteRatio < 0.2) {
+            // Write-heavy workload
+            this.cacheStrategy.hotCacheRatio = 0.3;
+            this.cacheStrategy.prefetchAggressive = false;
+            this.cacheStrategy.writeBufferSize = 8000;
+        }
+        else {
+            // Balanced workload
+            this.cacheStrategy.hotCacheRatio = 0.5;
+            this.cacheStrategy.prefetchAggressive = false;
+            this.cacheStrategy.writeBufferSize = 5000;
+        }
+    }
+}
+/**
+ * Factory for creating operational modes
+ */
+export class OperationalModeFactory {
+    /**
+     * Create operational mode based on role
+     * @param role - The instance role
+     * @returns The appropriate operational mode
+     */
+    static createMode(role) {
+        switch (role) {
+            case 'reader':
+                return new ReaderMode();
+            case 'writer':
+                return new WriterMode();
+            case 'hybrid':
+                return new HybridMode();
+            default:
+                // Default to reader for safety
+                return new ReaderMode();
+        }
+    }
+    /**
+     * Create mode with custom cache strategy
+     * @param role - The instance role
+     * @param customStrategy - Custom cache strategy overrides
+     * @returns The operational mode with custom strategy
+     */
+    static createModeWithStrategy(role, customStrategy) {
+        const mode = this.createMode(role);
+        // Apply custom strategy overrides
+        mode.cacheStrategy = {
+            ...mode.cacheStrategy,
+            ...customStrategy
+        };
+        return mode;
+    }
+}
+//# sourceMappingURL=operationalModes.js.map