@soulcraft/brainy 1.5.0 → 2.0.1

package/dist/scripts/precomputePatternEmbeddings.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * 🧠 Pre-compute Pattern Embeddings Script
+ *
+ * This script pre-computes embeddings for all patterns and saves them to disk.
+ * Run this once after adding new patterns to avoid runtime embedding costs.
+ *
+ * How it works:
+ * 1. Load all patterns from library.json
+ * 2. Use Brainy's embedding model to encode each pattern's examples
+ * 3. Average the example embeddings to get a robust pattern representation
+ * 4. Save embeddings to patterns/embeddings.bin for instant loading
+ *
+ * Benefits:
+ * - Pattern matching becomes pure math (cosine similarity)
+ * - No embedding model calls during query processing
+ * - Patterns load instantly with pre-computed vectors
+ */
+import { BrainyData } from '../brainyData.js';
+import patternData from '../patterns/library.json' assert { type: 'json' };
+import * as fs from 'fs/promises';
+import * as path from 'path';
+async function precomputeEmbeddings() {
+    console.log('🧠 Pre-computing pattern embeddings...');
+    // Initialize Brainy with minimal config
+    const brain = new BrainyData({
+        storage: { forceMemoryStorage: true },
+        logging: { verbose: false }
+    });
+    await brain.init();
+    console.log('✅ Brainy initialized');
+    const embeddings = {};
+    let processedCount = 0;
+    const totalPatterns = patternData.patterns.length;
+    for (const pattern of patternData.patterns) {
+        console.log(`\n📝 Processing pattern: ${pattern.id} (${++processedCount}/${totalPatterns})`);
+        console.log(`   Category: ${pattern.category}`);
+        console.log(`   Examples: ${pattern.examples.length}`);
+        // Embed all examples
+        const exampleEmbeddings = [];
+        for (const example of pattern.examples) {
+            try {
+                const embedding = await brain.embed(example);
+                exampleEmbeddings.push(embedding);
+                console.log(`   ✓ Embedded: "${example.substring(0, 50)}..."`);
+            }
+            catch (error) {
+                console.error(`   ✗ Failed to embed: "${example}"`, error);
+            }
+        }
+        if (exampleEmbeddings.length === 0) {
+            console.warn(`   ⚠️ No embeddings generated for pattern ${pattern.id}`);
+            continue;
+        }
+        // Average the embeddings for a robust representation
+        const avgEmbedding = averageVectors(exampleEmbeddings);
+        embeddings[pattern.id] = {
+            patternId: pattern.id,
+            embedding: avgEmbedding,
+            examples: pattern.examples,
+            averageMethod: 'arithmetic_mean'
+        };
+        console.log(`   ✅ Generated ${avgEmbedding.length}-dimensional embedding`);
+    }
+    // Save embeddings to file
+    const outputPath = path.join(process.cwd(), 'src', 'patterns', 'embeddings.json');
+    await fs.writeFile(outputPath, JSON.stringify(embeddings, null, 2));
+    console.log(`\n✅ Saved ${Object.keys(embeddings).length} pattern embeddings to ${outputPath}`);
+    // Calculate storage size
+    const stats = await fs.stat(outputPath);
+    console.log(`📊 File size: ${(stats.size / 1024).toFixed(2)} KB`);
+    // Print statistics
+    console.log('\n📈 Embedding Statistics:');
+    console.log(`   Total patterns: ${totalPatterns}`);
+    console.log(`   Successfully embedded: ${Object.keys(embeddings).length}`);
+    console.log(`   Failed: ${totalPatterns - Object.keys(embeddings).length}`);
+    console.log(`   Embedding dimensions: ${Object.values(embeddings)[0]?.embedding.length || 0}`);
+    await brain.close();
+    console.log('\n✅ Complete!');
+}
+function averageVectors(vectors) {
+    if (vectors.length === 0)
+        return [];
+    const dim = vectors[0].length;
+    const avg = new Array(dim).fill(0);
+    // Sum all vectors
+    for (const vec of vectors) {
+        for (let i = 0; i < dim; i++) {
+            avg[i] += vec[i];
+        }
+    }
+    // Divide by count to get average
+    for (let i = 0; i < dim; i++) {
+        avg[i] /= vectors.length;
+    }
+    return avg;
+}
+// Run the script
+precomputeEmbeddings().catch(console.error);
+//# sourceMappingURL=precomputePatternEmbeddings.js.map

package/dist/storage/adapters/fileSystemStorage.d.ts

@@ -136,6 +136,11 @@ export declare class FileSystemStorage extends BaseStorage {
      * Clear all data from storage
      */
     clear(): Promise<void>;
+    /**
+     * Enhanced clear operation with safety mechanisms and performance optimizations
+     * Provides progress tracking, backup options, and instance name confirmation
+     */
+    clearEnhanced(options?: import('../enhancedClearOperations.js').ClearOptions): Promise<import('../enhancedClearOperations.js').ClearResult>;
     /**
      * Get information about storage usage and capacity
      */

package/dist/storage/adapters/fileSystemStorage.js

@@ -600,6 +600,26 @@ export class FileSystemStorage extends BaseStorage {
         this.statisticsCache = null;
         this.statisticsModified = false;
     }
+    /**
+     * Enhanced clear operation with safety mechanisms and performance optimizations
+     * Provides progress tracking, backup options, and instance name confirmation
+     */
+    async clearEnhanced(options = {}) {
+        await this.ensureInitialized();
+        // Check if fs module is available
+        if (!fs || !fs.promises) {
+            throw new Error('FileSystemStorage.clearEnhanced: fs module not available');
+        }
+        const { EnhancedFileSystemClear } = await import('../enhancedClearOperations.js');
+        const enhancedClear = new EnhancedFileSystemClear(this.rootDir, fs, path);
+        const result = await enhancedClear.clear(options);
+        if (result.success) {
+            // Clear the statistics cache
+            this.statisticsCache = null;
+            this.statisticsModified = false;
+        }
+        return result;
+    }
     /**
      * Get information about storage usage and capacity
      */

package/dist/storage/adapters/s3CompatibleStorage.d.ts

@@ -358,6 +358,11 @@ export declare class S3CompatibleStorage extends BaseStorage {
      * Clear all data from storage
      */
     clear(): Promise<void>;
+    /**
+     * Enhanced clear operation with safety mechanisms and performance optimizations
+     * Provides progress tracking, backup options, and instance name confirmation
+     */
+    clearEnhanced(options?: import('../enhancedClearOperations.js').ClearOptions): Promise<import('../enhancedClearOperations.js').ClearResult>;
     /**
      * Get information about storage usage and capacity
      * Optimized version that uses cached statistics instead of expensive full scans

package/dist/storage/adapters/s3CompatibleStorage.js

@@ -1800,6 +1800,22 @@ export class S3CompatibleStorage extends BaseStorage {
             throw new Error(`Failed to clear storage: ${error}`);
         }
     }
+    /**
+     * Enhanced clear operation with safety mechanisms and performance optimizations
+     * Provides progress tracking, backup options, and instance name confirmation
+     */
+    async clearEnhanced(options = {}) {
+        await this.ensureInitialized();
+        const { EnhancedS3Clear } = await import('../enhancedClearOperations.js');
+        const enhancedClear = new EnhancedS3Clear(this.s3Client, this.bucketName);
+        const result = await enhancedClear.clear(options);
+        if (result.success) {
+            // Clear the statistics cache
+            this.statisticsCache = null;
+            this.statisticsModified = false;
+        }
+        return result;
+    }
     /**
      * Get information about storage usage and capacity
      * Optimized version that uses cached statistics instead of expensive full scans

package/dist/storage/enhancedClearOperations.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Enhanced Clear/Delete Operations for Brainy Storage
+ * Provides safe, efficient, and production-ready bulk deletion methods
+ */
+export interface ClearOptions {
+    /**
+     * Safety confirmation - must match database instance name
+     * Prevents accidental deletion of wrong databases
+     */
+    confirmInstanceName?: string;
+    /**
+     * Performance optimization settings
+     */
+    batchSize?: number;
+    maxConcurrency?: number;
+    /**
+     * Safety mechanisms
+     */
+    dryRun?: boolean;
+    createBackup?: boolean;
+    /**
+     * Progress callback for large operations
+     */
+    onProgress?: (progress: ClearProgress) => void;
+}
+export interface ClearProgress {
+    stage: 'backup' | 'nouns' | 'verbs' | 'metadata' | 'system' | 'cache' | 'complete';
+    totalItems: number;
+    processedItems: number;
+    errors: number;
+    estimatedTimeRemaining?: number;
+}
+export interface ClearResult {
+    success: boolean;
+    itemsDeleted: {
+        nouns: number;
+        verbs: number;
+        metadata: number;
+        system: number;
+    };
+    duration: number;
+    errors: Error[];
+    backupLocation?: string;
+}
+/**
+ * Enhanced FileSystem bulk delete operations
+ */
+export declare class EnhancedFileSystemClear {
+    private rootDir;
+    private fs;
+    private path;
+    constructor(rootDir: string, fs: any, path: any);
+    /**
+     * Optimized bulk delete for filesystem storage
+     * Uses parallel deletion with controlled concurrency
+     */
+    clear(options?: ClearOptions): Promise<ClearResult>;
+    /**
+     * High-performance directory clearing with controlled concurrency
+     */
+    private clearDirectoryOptimized;
+    private createBackup;
+    private performDryRun;
+}
+/**
+ * Enhanced S3 bulk delete operations
+ */
+export declare class EnhancedS3Clear {
+    private s3Client;
+    private bucketName;
+    constructor(s3Client: any, bucketName: string);
+    /**
+     * Optimized bulk delete for S3 storage
+     * Uses batch delete operations for maximum efficiency
+     */
+    clear(options?: ClearOptions): Promise<ClearResult>;
+    /**
+     * High-performance prefix clearing using S3 batch delete
+     */
+    private clearPrefixOptimized;
+    private getBucketInfo;
+    private performDryRun;
+}

package/dist/storage/enhancedClearOperations.js

@@ -0,0 +1,345 @@
+/**
+ * Enhanced Clear/Delete Operations for Brainy Storage
+ * Provides safe, efficient, and production-ready bulk deletion methods
+ */
+/**
+ * Enhanced FileSystem bulk delete operations
+ */
+export class EnhancedFileSystemClear {
+    constructor(rootDir, fs, path) {
+        this.rootDir = rootDir;
+        this.fs = fs;
+        this.path = path;
+    }
+    /**
+     * Optimized bulk delete for filesystem storage
+     * Uses parallel deletion with controlled concurrency
+     */
+    async clear(options = {}) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            itemsDeleted: { nouns: 0, verbs: 0, metadata: 0, system: 0 },
+            duration: 0,
+            errors: []
+        };
+        try {
+            // Safety checks
+            if (options.confirmInstanceName) {
+                const actualName = this.path.basename(this.rootDir);
+                if (actualName !== options.confirmInstanceName) {
+                    throw new Error(`Instance name mismatch: expected '${options.confirmInstanceName}', got '${actualName}'`);
+                }
+            }
+            // Create backup if requested
+            if (options.createBackup) {
+                result.backupLocation = await this.createBackup();
+                options.onProgress?.({
+                    stage: 'backup',
+                    totalItems: 1,
+                    processedItems: 1,
+                    errors: 0
+                });
+            }
+            // Dry run - just count items
+            if (options.dryRun) {
+                return await this.performDryRun(options);
+            }
+            // Optimized deletion with batching
+            const batchSize = options.batchSize || 100;
+            const maxConcurrency = options.maxConcurrency || 10;
+            // Delete nouns directory with optimization
+            result.itemsDeleted.nouns = await this.clearDirectoryOptimized(this.path.join(this.rootDir, 'nouns'), batchSize, maxConcurrency, (progress) => options.onProgress?.({ ...progress, stage: 'nouns' }));
+            // Delete verbs directory with optimization
+            result.itemsDeleted.verbs = await this.clearDirectoryOptimized(this.path.join(this.rootDir, 'verbs'), batchSize, maxConcurrency, (progress) => options.onProgress?.({ ...progress, stage: 'verbs' }));
+            // Delete metadata directories
+            const metadataDirs = ['metadata', 'noun-metadata', 'verb-metadata'];
+            for (const dir of metadataDirs) {
+                result.itemsDeleted.metadata += await this.clearDirectoryOptimized(this.path.join(this.rootDir, dir), batchSize, maxConcurrency, (progress) => options.onProgress?.({ ...progress, stage: 'metadata' }));
+            }
+            // Delete system directories
+            const systemDirs = ['system', 'index'];
+            for (const dir of systemDirs) {
+                result.itemsDeleted.system += await this.clearDirectoryOptimized(this.path.join(this.rootDir, dir), batchSize, maxConcurrency, (progress) => options.onProgress?.({ ...progress, stage: 'system' }));
+            }
+            result.success = true;
+            result.duration = Date.now() - startTime;
+            options.onProgress?.({
+                stage: 'complete',
+                totalItems: Object.values(result.itemsDeleted).reduce((a, b) => a + b, 0),
+                processedItems: Object.values(result.itemsDeleted).reduce((a, b) => a + b, 0),
+                errors: result.errors.length
+            });
+        }
+        catch (error) {
+            result.errors.push(error);
+            result.duration = Date.now() - startTime;
+        }
+        return result;
+    }
+    /**
+     * High-performance directory clearing with controlled concurrency
+     */
+    async clearDirectoryOptimized(dirPath, batchSize, maxConcurrency, onProgress) {
+        try {
+            // Check if directory exists
+            const stats = await this.fs.promises.stat(dirPath);
+            if (!stats.isDirectory())
+                return 0;
+            // Get all files in the directory
+            const files = await this.fs.promises.readdir(dirPath);
+            const totalFiles = files.length;
+            if (totalFiles === 0)
+                return 0;
+            let processedFiles = 0;
+            let errors = 0;
+            // Process files in batches with controlled concurrency
+            for (let i = 0; i < files.length; i += batchSize) {
+                const batch = files.slice(i, i + batchSize);
+                // Create semaphore for concurrency control
+                const semaphore = new Array(Math.min(maxConcurrency, batch.length)).fill(0);
+                await Promise.all(batch.map(async (file, index) => {
+                    // Wait for semaphore slot
+                    await new Promise(resolve => {
+                        const slotIndex = index % semaphore.length;
+                        semaphore[slotIndex] = performance.now();
+                        resolve(undefined);
+                    });
+                    try {
+                        const filePath = this.path.join(dirPath, file);
+                        await this.fs.promises.unlink(filePath);
+                        processedFiles++;
+                    }
+                    catch (error) {
+                        errors++;
+                        console.warn(`Failed to delete file ${file}:`, error);
+                    }
+                    // Report progress every 50 files or at end of batch
+                    if (processedFiles % 50 === 0 || processedFiles === totalFiles) {
+                        onProgress?.({
+                            totalItems: totalFiles,
+                            processedItems: processedFiles,
+                            errors
+                        });
+                    }
+                }));
+                // Small yield between batches to prevent blocking
+                await new Promise(resolve => setImmediate(resolve));
+            }
+            return processedFiles;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return 0; // Directory doesn't exist, that's fine
+            }
+            throw error;
+        }
+    }
+    async createBackup() {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupDir = `${this.rootDir}-backup-${timestamp}`;
+        // Use cp -r for efficient directory copying
+        const { spawn } = await import('child_process');
+        return new Promise((resolve, reject) => {
+            const cp = spawn('cp', ['-r', this.rootDir, backupDir]);
+            cp.on('close', (code) => {
+                if (code === 0) {
+                    resolve(backupDir);
+                }
+                else {
+                    reject(new Error(`Backup failed with code ${code}`));
+                }
+            });
+            cp.on('error', reject);
+        });
+    }
+    async performDryRun(options) {
+        const startTime = Date.now();
+        const result = {
+            success: true,
+            itemsDeleted: { nouns: 0, verbs: 0, metadata: 0, system: 0 },
+            duration: 0,
+            errors: []
+        };
+        const countFiles = async (dirPath) => {
+            try {
+                const files = await this.fs.promises.readdir(dirPath);
+                return files.filter((f) => f.endsWith('.json')).length;
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return 0;
+                throw error;
+            }
+        };
+        result.itemsDeleted.nouns = await countFiles(this.path.join(this.rootDir, 'nouns'));
+        result.itemsDeleted.verbs = await countFiles(this.path.join(this.rootDir, 'verbs'));
+        result.itemsDeleted.metadata =
+            await countFiles(this.path.join(this.rootDir, 'metadata')) +
+                await countFiles(this.path.join(this.rootDir, 'noun-metadata')) +
+                await countFiles(this.path.join(this.rootDir, 'verb-metadata'));
+        result.itemsDeleted.system =
+            await countFiles(this.path.join(this.rootDir, 'system')) +
+                await countFiles(this.path.join(this.rootDir, 'index'));
+        result.duration = Date.now() - startTime;
+        return result;
+    }
+}
+/**
+ * Enhanced S3 bulk delete operations
+ */
+export class EnhancedS3Clear {
+    constructor(s3Client, bucketName) {
+        this.s3Client = s3Client;
+        this.bucketName = bucketName;
+    }
+    /**
+     * Optimized bulk delete for S3 storage
+     * Uses batch delete operations for maximum efficiency
+     */
+    async clear(options = {}) {
+        const startTime = Date.now();
+        const result = {
+            success: false,
+            itemsDeleted: { nouns: 0, verbs: 0, metadata: 0, system: 0 },
+            duration: 0,
+            errors: []
+        };
+        try {
+            // Safety checks
+            if (options.confirmInstanceName) {
+                // Extract instance name from bucket structure or prefix
+                const bucketInfo = await this.getBucketInfo();
+                if (bucketInfo.instanceName !== options.confirmInstanceName) {
+                    throw new Error(`Instance name mismatch: expected '${options.confirmInstanceName}', got '${bucketInfo.instanceName}'`);
+                }
+            }
+            // Dry run - just count objects
+            if (options.dryRun) {
+                return await this.performDryRun(options);
+            }
+            // AWS S3 batch delete supports up to 1000 objects per request
+            const batchSize = Math.min(options.batchSize || 1000, 1000);
+            // Delete with optimized batching
+            const prefixes = [
+                { prefix: 'nouns/', key: 'nouns' },
+                { prefix: 'verbs/', key: 'verbs' },
+                { prefix: 'metadata/', key: 'metadata' },
+                { prefix: 'noun-metadata/', key: 'metadata' },
+                { prefix: 'verb-metadata/', key: 'metadata' },
+                { prefix: 'system/', key: 'system' },
+                { prefix: 'index/', key: 'system' }
+            ];
+            for (const { prefix, key } of prefixes) {
+                const deleted = await this.clearPrefixOptimized(prefix, batchSize, (progress) => options.onProgress?.({
+                    ...progress,
+                    stage: key === 'nouns' ? 'nouns' :
+                        key === 'verbs' ? 'verbs' :
+                            key === 'metadata' ? 'metadata' : 'system'
+                }));
+                result.itemsDeleted[key] += deleted;
+            }
+            result.success = true;
+            result.duration = Date.now() - startTime;
+        }
+        catch (error) {
+            result.errors.push(error);
+            result.duration = Date.now() - startTime;
+        }
+        return result;
+    }
+    /**
+     * High-performance prefix clearing using S3 batch delete
+     */
+    async clearPrefixOptimized(prefix, batchSize, onProgress) {
+        const { ListObjectsV2Command, DeleteObjectsCommand } = await import('@aws-sdk/client-s3');
+        let totalDeleted = 0;
+        let continuationToken;
+        do {
+            // List objects with the prefix
+            const listResponse = await this.s3Client.send(new ListObjectsV2Command({
+                Bucket: this.bucketName,
+                Prefix: prefix,
+                MaxKeys: batchSize,
+                ContinuationToken: continuationToken
+            }));
+            if (!listResponse.Contents || listResponse.Contents.length === 0) {
+                break;
+            }
+            // Prepare batch delete request
+            const objectsToDelete = listResponse.Contents
+                .filter((obj) => obj.Key)
+                .map((obj) => ({ Key: obj.Key }));
+            if (objectsToDelete.length > 0) {
+                // Perform batch delete
+                const deleteResponse = await this.s3Client.send(new DeleteObjectsCommand({
+                    Bucket: this.bucketName,
+                    Delete: {
+                        Objects: objectsToDelete,
+                        Quiet: false // Get detailed response
+                    }
+                }));
+                const deletedCount = deleteResponse.Deleted?.length || 0;
+                totalDeleted += deletedCount;
+                // Report any errors
+                if (deleteResponse.Errors && deleteResponse.Errors.length > 0) {
+                    for (const error of deleteResponse.Errors) {
+                        console.warn(`Failed to delete ${error.Key}: ${error.Message}`);
+                    }
+                }
+                // Report progress
+                onProgress?.({
+                    totalItems: totalDeleted + (listResponse.IsTruncated ? 1000 : 0), // Estimate
+                    processedItems: totalDeleted,
+                    errors: deleteResponse.Errors?.length || 0
+                });
+            }
+            continuationToken = listResponse.NextContinuationToken;
+            // Small delay to respect AWS rate limits
+            await new Promise(resolve => setTimeout(resolve, 10));
+        } while (continuationToken);
+        return totalDeleted;
+    }
+    async getBucketInfo() {
+        // Each Brainy instance has its own bucket with the same name as the instance
+        // The bucket name IS the instance name
+        return { instanceName: this.bucketName };
+    }
+    async performDryRun(options) {
+        const startTime = Date.now();
+        const { ListObjectsV2Command } = await import('@aws-sdk/client-s3');
+        const result = {
+            success: true,
+            itemsDeleted: { nouns: 0, verbs: 0, metadata: 0, system: 0 },
+            duration: 0,
+            errors: []
+        };
+        const countObjects = async (prefix) => {
+            let count = 0;
+            let continuationToken;
+            do {
+                const response = await this.s3Client.send(new ListObjectsV2Command({
+                    Bucket: this.bucketName,
+                    Prefix: prefix,
+                    MaxKeys: 1000,
+                    ContinuationToken: continuationToken
+                }));
+                count += response.KeyCount || 0;
+                continuationToken = response.NextContinuationToken;
+            } while (continuationToken);
+            return count;
+        };
+        result.itemsDeleted.nouns = await countObjects('nouns/');
+        result.itemsDeleted.verbs = await countObjects('verbs/');
+        result.itemsDeleted.metadata =
+            await countObjects('metadata/') +
+                await countObjects('noun-metadata/') +
+                await countObjects('verb-metadata/');
+        result.itemsDeleted.system =
+            await countObjects('system/') +
+                await countObjects('index/');
+        result.duration = Date.now() - startTime;
+        return result;
+    }
+}
+//# sourceMappingURL=enhancedClearOperations.js.map

package/dist/storage/storageFactory.js

@@ -181,38 +181,42 @@ export async function createStorage(options = {}) {
         });
     }
     // Auto-detect the best storage adapter based on the environment
-    // First, try OPFS (browser only)
-    const opfsStorage = new OPFSStorage();
-    if (opfsStorage.isOPFSAvailable()) {
-        console.log('Using OPFS storage (auto-detected)');
-        await opfsStorage.init();
-        // Request persistent storage if specified
-        if (options.requestPersistentStorage) {
-            const isPersistent = await opfsStorage.requestPersistentStorage();
-            console.log(`Persistent storage ${isPersistent ? 'granted' : 'denied'}`);
+    // First, check if we're in Node.js (prioritize for test environments)
+    if (!isBrowser()) {
+        try {
+            // Check if we're in a Node.js environment
+            if (typeof process !== 'undefined' &&
+                process.versions &&
+                process.versions.node) {
+                console.log('Using file system storage (auto-detected)');
+                try {
+                    const { FileSystemStorage } = await import('./adapters/fileSystemStorage.js');
+                    return new FileSystemStorage(options.rootDirectory || './brainy-data');
+                }
+                catch (fsError) {
+                    console.warn('Failed to load FileSystemStorage, falling back to memory storage:', fsError);
+                }
+            }
+        }
+        catch (error) {
+            // Not in a Node.js environment or file system is not available
+            console.warn('Not in a Node.js environment:', error);
         }
-        return opfsStorage;
     }
-    // Next, try file system storage (Node.js only)
-    try {
-        // Check if we're in a Node.js environment
-        if (typeof process !== 'undefined' &&
-            process.versions &&
-            process.versions.node) {
-            console.log('Using file system storage (auto-detected)');
-            try {
-                const { FileSystemStorage } = await import('./adapters/fileSystemStorage.js');
-                return new FileSystemStorage(options.rootDirectory || './brainy-data');
-            }
-            catch (fsError) {
-                console.warn('Failed to load FileSystemStorage, falling back to memory storage:', fsError);
+    // Next, try OPFS (browser only)
+    if (isBrowser()) {
+        const opfsStorage = new OPFSStorage();
+        if (opfsStorage.isOPFSAvailable()) {
+            console.log('Using OPFS storage (auto-detected)');
+            await opfsStorage.init();
+            // Request persistent storage if specified
+            if (options.requestPersistentStorage) {
+                const isPersistent = await opfsStorage.requestPersistentStorage();
+                console.log(`Persistent storage ${isPersistent ? 'granted' : 'denied'}`);
             }
+            return opfsStorage;
         }
     }
-    catch (error) {
-        // Not in a Node.js environment or file system is not available
-        console.warn('Not in a Node.js environment:', error);
-    }
     // Finally, fall back to memory storage
     console.log('Using memory storage (auto-detected)');
     return new MemoryStorage();