@soulcraft/brainy 0.9.37 → 0.11.0

package/dist/unified.js

@@ -2398,133 +2398,84 @@ ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  * Unified Text Encoding Utilities
  *
  * This module provides a consistent way to handle text encoding/decoding across all environments
- * without relying on TextEncoder/TextDecoder polyfills or patches.
+ * using the native TextEncoder/TextDecoder APIs.
  */
-/**
- * A simple text encoder that works in all environments
- * This avoids the need for TextEncoder polyfills and patches
- */
-class SimpleTextEncoder {
-    /**
-     * Encode a string to a Uint8Array
-     * @param input - The string to encode
-     * @returns A Uint8Array containing the encoded string
-     */
-    encode(input) {
-        // Simple UTF-8 encoding implementation that works everywhere
-        return new Uint8Array([...input].map((c) => c.charCodeAt(0)));
-    }
-}
-/**
- * A simple text decoder that works in all environments
- * This avoids the need for TextDecoder polyfills and patches
- */
-class SimpleTextDecoder {
-    /**
-     * Decode a Uint8Array to a string
-     * @param input - The Uint8Array to decode
-     * @returns The decoded string
-     */
-    decode(input) {
-        // Simple UTF-8 decoding implementation that works everywhere
-        return String.fromCharCode.apply(null, [...input]);
-    }
-}
-/**
- * A constructor function for TextEncoder that works in all environments
- */
-function UniversalTextEncoder() {
-    if (!(this instanceof UniversalTextEncoder)) {
-        return new UniversalTextEncoder();
-    }
-    try {
-        // Try to use the native TextEncoder if available
-        const nativeEncoder = new TextEncoder();
-        this.encode = nativeEncoder.encode.bind(nativeEncoder);
-    }
-    catch (e) {
-        // Fall back to our simple implementation
-        const simpleEncoder = new SimpleTextEncoder();
-        this.encode = simpleEncoder.encode.bind(simpleEncoder);
-    }
-}
-/**
- * A constructor function for TextDecoder that works in all environments
- */
-function UniversalTextDecoder() {
-    if (!(this instanceof UniversalTextDecoder)) {
-        return new UniversalTextDecoder();
-    }
-    try {
-        // Try to use the native TextDecoder if available
-        const nativeDecoder = new TextDecoder();
-        this.decode = nativeDecoder.decode.bind(nativeDecoder);
-    }
-    catch (e) {
-        // Fall back to our simple implementation
-        const simpleDecoder = new SimpleTextDecoder();
-        this.decode = simpleDecoder.decode.bind(simpleDecoder);
-    }
-}
 /**
  * Get a text encoder that works in the current environment
- * @returns A text encoder object with an encode method
+ * @returns A TextEncoder instance
  */
-function getTextEncoder() {
-    return new UniversalTextEncoder();
-}
-/**
- * Get a text decoder that works in the current environment
- * @returns A text decoder object with a decode method
- */
-function getTextDecoder() {
-    return new UniversalTextDecoder();
-}
 /**
  * Apply the TensorFlow.js platform patch if needed
  * This function patches the global object to provide a PlatformNode class
- * that uses our text encoding utilities instead of relying on TextEncoder/TextDecoder
+ * that uses native TextEncoder/TextDecoder
  */
 function applyTensorFlowPatch() {
-    // Only apply in Node.js environment
-    if (typeof global !== 'undefined' &&
-        typeof process !== 'undefined' &&
-        process.versions &&
-        process.versions.node) {
-        try {
-            // Get encoders/decoders
-            const encoder = getTextEncoder();
-            const decoder = getTextDecoder();
-            // Define a custom PlatformNode class
-            class PlatformNode {
-                constructor() {
-                    // Create a util object with necessary methods and constructors
-                    this.util = {
-                        isFloat32Array: (arr) => !!(arr instanceof Float32Array ||
-                            (arr &&
-                                Object.prototype.toString.call(arr) ===
-                                    '[object Float32Array]')),
-                        isTypedArray: (arr) => !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView)),
-                        // Add TextEncoder and TextDecoder as constructors
-                        TextEncoder: UniversalTextEncoder,
-                        TextDecoder: UniversalTextDecoder
-                    };
-                    // Initialize using the constructors from util
-                    this.textEncoder = new TextEncoder();
-                    this.textDecoder = new TextDecoder();
-                }
-            }
-            // Assign the PlatformNode class to the global object
+    try {
+        // Define a custom Platform class that works in both Node.js and browser environments
+        class Platform {
+            constructor() {
+                // Create a util object with necessary methods and constructors
+                this.util = {
+                    // Use native TextEncoder and TextDecoder
+                    TextEncoder: globalThis.TextEncoder || TextEncoder,
+                    TextDecoder: globalThis.TextDecoder || TextDecoder
+                };
+                // Initialize using native constructors directly
+                this.textEncoder = new (globalThis.TextEncoder || TextEncoder)();
+                this.textDecoder = new (globalThis.TextDecoder || TextDecoder)();
+            }
+            // Define isFloat32Array directly on the instance
+            isFloat32Array(arr) {
+                return !!(arr instanceof Float32Array ||
+                    (arr &&
+                        Object.prototype.toString.call(arr) === '[object Float32Array]'));
+            }
+            // Define isTypedArray directly on the instance
+            isTypedArray(arr) {
+                return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+            }
+        }
+        // Get the global object in a way that works in both Node.js and browser
+        const globalObj = typeof global !== 'undefined'
+            ? global
+            : typeof window !== 'undefined'
+                ? window
+                : typeof self !== 'undefined'
+                    ? self
+                    : {};
+        // Only apply in Node.js environment
+        if (typeof process !== 'undefined' &&
+            process.versions &&
+            process.versions.node) {
+            // Assign the Platform class to the global object as PlatformNode for Node.js
             ;
-            global.PlatformNode = PlatformNode;
-            global.platformNode = new PlatformNode();
+            globalObj.PlatformNode = Platform;
+            globalObj.platformNode = new Platform();
         }
-        catch (error) {
-            console.warn('Failed to apply TensorFlow.js platform patch:', error);
+        else if (typeof window !== 'undefined' || typeof self !== 'undefined') {
+            // In browser environments, we might need to provide similar functionality
+            // but we'll use a different name to avoid conflicts
+            ;
+            globalObj.PlatformBrowser = Platform;
+            globalObj.platformBrowser = new Platform();
         }
     }
+    catch (error) {
+        console.warn('Failed to apply TensorFlow.js platform patch:', error);
+    }
 }
 
+/**
+ * This file is imported for its side effects to patch the environment
+ * for TensorFlow.js before any other library code runs.
+ *
+ * It ensures that by the time TensorFlow.js is imported by any other
+ * module, the necessary compatibility fixes for the current Node.js
+ * environment are already in place.
+ */
+// Apply the TensorFlow.js platform patch if needed
+applyTensorFlowPatch();
+
 // Unique ID creation requires a high quality random # generator. In the browser we therefore
 // require the crypto API and do not support built-in fallback to lower quality random number
 // generators (like Math.random()).
@@ -2853,7 +2804,7 @@ async function areWorkerThreadsAvailable() {
 function areWorkerThreadsAvailableSync() {
     if (!isNode())
         return false;
-    // In Node.js 24.3.0+, worker_threads is always available
+    // In Node.js 24.4.0+, worker_threads is always available
     return parseInt(process.versions.node.split('.')[0]) >= 24;
 }
 /**
@@ -2913,9 +2864,16 @@ function executeInThread(fnString, args) {
                         fn = new Function(fnString)();
                     }
                     catch (directError) {
-                        console.error('Fallback: All approaches to create function failed', directError);
-                        throw new Error('Failed to create function from string: ' +
-                            functionError.message);
+                        console.warn('Fallback: Direct approach failed, trying with function wrapper', directError);
+                        try {
+                            // Try wrapping in a function that returns the function expression
+                            fn = new Function('return function(args) { return (' + fnString + ')(args); }')();
+                        }
+                        catch (wrapperError) {
+                            console.error('Fallback: All approaches to create function failed', wrapperError);
+                            throw new Error('Failed to create function from string: ' +
+                                functionError.message);
+                        }
                     }
                 }
             }
@@ -2950,6 +2908,82 @@ function executeInNodeWorker(fnString, args) {
                     // Create a new worker
                     worker = new Worker(`
             import { parentPort, workerData } from 'node:worker_threads';
+
+            // Add TensorFlow.js platform patch for Node.js
+            if (typeof global !== 'undefined') {
+              try {
+                // Define a custom PlatformNode class
+                class PlatformNode {
+                  constructor() {
+                    // Create a util object with necessary methods
+                    this.util = {
+                      // Add isFloat32Array and isTypedArray directly to util
+                      isFloat32Array: (arr) => {
+                        return !!(
+                          arr instanceof Float32Array ||
+                          (arr &&
+                            Object.prototype.toString.call(arr) === '[object Float32Array]')
+                        );
+                      },
+                      isTypedArray: (arr) => {
+                        return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                      },
+                      // Use native TextEncoder and TextDecoder
+                      TextEncoder: TextEncoder,
+                      TextDecoder: TextDecoder
+                    };
+
+                    // Initialize encoders using native constructors
+                    this.textEncoder = new TextEncoder();
+                    this.textDecoder = new TextDecoder();
+                  }
+
+                  // Define isFloat32Array directly on the instance
+                  isFloat32Array(arr) {
+                    return !!(
+                      arr instanceof Float32Array ||
+                      (arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
+                    );
+                  }
+
+                  // Define isTypedArray directly on the instance
+                  isTypedArray(arr) {
+                    return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                  }
+                }
+
+                // Assign the PlatformNode class to the global object
+                global.PlatformNode = PlatformNode;
+
+                // Also create an instance and assign it to global.platformNode
+                global.platformNode = new PlatformNode();
+
+                // Ensure global.util exists and has the necessary methods
+                if (!global.util) {
+                  global.util = {};
+                }
+
+                // Add isFloat32Array method if it doesn't exist
+                if (!global.util.isFloat32Array) {
+                  global.util.isFloat32Array = (arr) => {
+                    return !!(
+                      arr instanceof Float32Array ||
+                      (arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
+                    );
+                  };
+                }
+
+                // Add isTypedArray method if it doesn't exist
+                if (!global.util.isTypedArray) {
+                  global.util.isTypedArray = (arr) => {
+                    return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                  };
+                }
+              } catch (error) {
+                console.warn('Failed to apply TensorFlow.js platform patch:', error);
+              }
+            }
+
             const fn = new Function('return ' + workerData.fnString)();
             const result = fn(workerData.args);
             parentPort.postMessage({ result });
@@ -2969,6 +3003,71 @@ function executeInNodeWorker(fnString, args) {
                         worker.terminate();
                         worker = new Worker(`
               import { parentPort, workerData } from 'node:worker_threads';
+
+              // Add TensorFlow.js platform patch for Node.js
+              if (typeof global !== 'undefined') {
+                try {
+                  // Define a custom PlatformNode class
+                  class PlatformNode {
+                    constructor() {
+                      // Create a util object with necessary methods
+                      this.util = {
+                        // Use native TextEncoder and TextDecoder
+                        TextEncoder: TextEncoder,
+                        TextDecoder: TextDecoder
+                      };
+
+                      // Initialize encoders using native constructors
+                      this.textEncoder = new TextEncoder();
+                      this.textDecoder = new TextDecoder();
+                    }
+
+                    // Define isFloat32Array directly on the instance
+                    isFloat32Array(arr) {
+                      return !!(
+                        arr instanceof Float32Array ||
+                        (arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
+                      );
+                    }
+
+                    // Define isTypedArray directly on the instance
+                    isTypedArray(arr) {
+                      return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                    }
+                  }
+
+                  // Assign the PlatformNode class to the global object
+                  global.PlatformNode = PlatformNode;
+
+                  // Also create an instance and assign it to global.platformNode
+                  global.platformNode = new PlatformNode();
+
+                  // Ensure global.util exists and has the necessary methods
+                  if (!global.util) {
+                    global.util = {};
+                  }
+
+                  // Add isFloat32Array method if it doesn't exist
+                  if (!global.util.isFloat32Array) {
+                    global.util.isFloat32Array = (arr) => {
+                      return !!(
+                        arr instanceof Float32Array ||
+                        (arr && Object.prototype.toString.call(arr) === '[object Float32Array]')
+                      );
+                    };
+                  }
+
+                  // Add isTypedArray method if it doesn't exist
+                  if (!global.util.isTypedArray) {
+                    global.util.isTypedArray = (arr) => {
+                      return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                    };
+                  }
+                } catch (error) {
+                  console.warn('Failed to apply TensorFlow.js platform patch:', error);
+                }
+              }
+
               const fn = new Function('return ' + workerData.fnString)();
               const result = fn(workerData.args);
               parentPort.postMessage({ result });
@@ -3209,7 +3308,71 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
             !process.versions.node) {
             return;
         }
-        // No compatibility patches needed - TensorFlow.js now works correctly with Node.js 24+
+        // Add polyfill for isFloat32Array in Node.js 24.4.0
+        // This fixes the "Cannot read properties of undefined (reading 'isFloat32Array')" error
+        if (typeof global !== 'undefined') {
+            try {
+                // Define a custom PlatformNode class
+                class PlatformNode {
+                    constructor() {
+                        // Create a util object with necessary methods
+                        this.util = {
+                            // Add isFloat32Array and isTypedArray directly to util
+                            isFloat32Array: (arr) => {
+                                return !!(arr instanceof Float32Array ||
+                                    (arr &&
+                                        Object.prototype.toString.call(arr) ===
+                                            '[object Float32Array]'));
+                            },
+                            isTypedArray: (arr) => {
+                                return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                            },
+                            // Use native TextEncoder and TextDecoder
+                            TextEncoder: TextEncoder,
+                            TextDecoder: TextDecoder
+                        };
+                        // Initialize encoders using native constructors
+                        this.textEncoder = new TextEncoder();
+                        this.textDecoder = new TextDecoder();
+                    }
+                    // Define isFloat32Array directly on the instance
+                    isFloat32Array(arr) {
+                        return !!(arr instanceof Float32Array ||
+                            (arr &&
+                                Object.prototype.toString.call(arr) === '[object Float32Array]'));
+                    }
+                    // Define isTypedArray directly on the instance
+                    isTypedArray(arr) {
+                        return !!(ArrayBuffer.isView(arr) && !(arr instanceof DataView));
+                    }
+                }
+                // Assign the PlatformNode class to the global object
+                ;
+                global.PlatformNode = PlatformNode;
+                global.platformNode = new PlatformNode();
+            }
+            catch (error) {
+                console.warn('Failed to define global PlatformNode class:', error);
+            }
+            // Ensure the util object exists
+            if (!global.util) {
+                global.util = {};
+            }
+            // Add isFloat32Array method if it doesn't exist
+            if (!global.util.isFloat32Array) {
+                global.util.isFloat32Array = (obj) => {
+                    return !!(obj instanceof Float32Array ||
+                        (obj &&
+                            Object.prototype.toString.call(obj) === '[object Float32Array]'));
+                };
+            }
+            // Add isTypedArray method if it doesn't exist
+            if (!global.util.isTypedArray) {
+                global.util.isTypedArray = (obj) => {
+                    return !!(ArrayBuffer.isView(obj) && !(obj instanceof DataView));
+                };
+            }
+        }
     }
     /**
      * Initialize the embedding model
@@ -9625,12 +9788,40 @@ class BrainyData {
     }
 }
 
-// Import Node.js built-in modules
-// Using dynamic imports for compatibility with ES modules
+// Dynamically and asynchronously load Node.js modules at the top level.
+// This ensures they are available as soon as this module is imported,
+// preventing race conditions with dependencies like TensorFlow.js.
 let fs;
 let path;
-// We'll initialize these modules in the init() method
-// No synchronous loading here to avoid issues with ES modules
+const nodeModulesPromise = (async () => {
+    // A reliable check for a Node.js environment.
+    const isNode = typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null;
+    if (!isNode) {
+        return { fs: null, path: null };
+    }
+    try {
+        // Use the 'node:' prefix for unambiguous importing of built-in modules.
+        const fsModule = await import('node:fs');
+        const pathModule = await import('node:path');
+        // Return the modules, preferring the default export if it exists.
+        return {
+            fs: fsModule.default || fsModule,
+            path: pathModule.default || pathModule
+        };
+    }
+    catch (error) {
+        console.error('FileSystemStorage: Failed to load Node.js modules. This adapter is not supported in this environment.', error);
+        return { fs: null, path: null };
+    }
+})();
+// Immediately assign the modules once the promise resolves.
+nodeModulesPromise.then((modules) => {
+    fs = modules.fs;
+    path = modules.path;
+});
+// --- End of Refactored Code ---
 // Constants for directory and file names
 const ROOT_DIR = 'brainy-data';
 const NOUNS_DIR = 'nouns';
@@ -9670,58 +9861,13 @@ class FileSystemStorage {
         if (this.isInitialized) {
             return;
         }
+        // Wait for the top-level module loading to complete.
+        await nodeModulesPromise;
+        // Check if the modules were loaded successfully.
+        if (!fs || !path) {
+            throw new Error('FileSystemStorage requires a Node.js environment, but `fs` and `path` modules could not be loaded.');
+        }
         try {
-            // Check if fs and path modules are available and have required methods
-            if (!fs || !path || typeof path.resolve !== 'function') {
-                console.log('Node.js modules not properly loaded, attempting to load them now');
-                // Try multiple approaches to load the modules
-                const loadAttempts = [
-                    // Attempt 1: Use dynamic import
-                    async () => {
-                        console.log('Attempting to load Node.js modules with dynamic import');
-                        const fsModule = await import('fs');
-                        const pathModule = await import('path');
-                        const fsResolved = fsModule.default || fsModule;
-                        const pathResolved = pathModule.default || pathModule;
-                        if (!pathResolved || typeof pathResolved.resolve !== 'function') {
-                            throw new Error('path.resolve is not a function after dynamic import');
-                        }
-                        return { fs: fsResolved, path: pathResolved };
-                    },
-                    // Attempt 2: Use dynamic import with node: prefix
-                    async () => {
-                        console.log('Attempting to load Node.js modules with dynamic import("node:...")');
-                        const fsModule = await import('node:fs');
-                        const pathModule = await import('node:path');
-                        const fsResolved = fsModule.default || fsModule;
-                        const pathResolved = pathModule.default || pathModule;
-                        if (!pathResolved || typeof pathResolved.resolve !== 'function') {
-                            throw new Error('path.resolve is not a function after dynamic import("node:path")');
-                        }
-                        return { fs: fsResolved, path: pathResolved };
-                    }
-                ];
-                // Try each loading method until one succeeds
-                let lastError = null;
-                for (const loadAttempt of loadAttempts) {
-                    try {
-                        const modules = await loadAttempt();
-                        fs = modules.fs;
-                        path = modules.path;
-                        console.log('Successfully loaded Node.js modules');
-                        break;
-                    }
-                    catch (error) {
-                        lastError = error;
-                        console.warn(`Module loading attempt failed:`, error);
-                        // Continue to the next attempt
-                    }
-                }
-                // If all attempts failed, throw an error
-                if (!fs || !path || typeof path.resolve !== 'function') {
-                    throw new Error(`Failed to import Node.js modules after multiple attempts: ${lastError}. This adapter requires a Node.js environment.`);
-                }
-            }
             // Now set up the directory paths
             const rootDir = this.rootDir || process.cwd();
             this.rootDir = path.resolve(rootDir, ROOT_DIR);
@@ -9741,7 +9887,6 @@ class FileSystemStorage {
             await this.ensureDirectoryExists(this.nounsDir);
             await this.ensureDirectoryExists(this.verbsDir);
             await this.ensureDirectoryExists(this.metadataDir);
-            // Create noun type directories
             await this.ensureDirectoryExists(this.personDir);
             await this.ensureDirectoryExists(this.placeDir);
             await this.ensureDirectoryExists(this.thingDir);
@@ -9752,736 +9897,349 @@ class FileSystemStorage {
             this.isInitialized = true;
         }
         catch (error) {
-            console.error('Failed to initialize file system storage:', error);
-            throw new Error(`Failed to initialize file system storage: ${error}`);
+            console.error('Error initializing FileSystemStorage:', error);
+            throw error;
         }
     }
-    /**
-     * Save a node to storage
-     */
-    async saveNoun(noun) {
-        await this.ensureInitialized();
+    async ensureDirectoryExists(dirPath) {
         try {
-            // Convert connections Map to a serializable format
-            const serializableNode = {
-                ...noun,
-                connections: this.mapToObject(noun.connections, (set) => Array.from(set))
-            };
-            // Get the appropriate directory based on the node's metadata
-            const nodeDir = await this.getNodeDirectory(noun.id);
-            const filePath = path.join(nodeDir, `${noun.id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(serializableNode, null, 2), 'utf8');
+            await fs.promises.mkdir(dirPath, { recursive: true });
         }
         catch (error) {
-            console.error(`Failed to save node ${noun.id}:`, error);
-            throw new Error(`Failed to save node ${noun.id}: ${error}`);
-        }
-    }
-    /**
-     * Get a node from storage
-     */
-    async getNoun(id) {
-        await this.ensureInitialized();
-        try {
-            // Get the appropriate directory based on the node's metadata
-            const nodeDir = await this.getNodeDirectory(id);
-            const filePath = path.join(nodeDir, `${id}.json`);
-            // Check if a file exists
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                // If the file doesn't exist in the expected directory, try the default directory
-                if (nodeDir !== this.defaultDir) {
-                    const defaultFilePath = path.join(this.defaultDir, `${id}.json`);
-                    try {
-                        await fs.promises.access(defaultFilePath);
-                        // If found in default directory, use that path
-                        const data = await fs.promises.readFile(defaultFilePath, 'utf8');
-                        const parsedNode = JSON.parse(data);
-                        // Convert serialized connections back to Map<number, Set<string>>
-                        const connections = new Map();
-                        for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                            connections.set(Number(level), new Set(nodeIds));
-                        }
-                        return {
-                            id: parsedNode.id,
-                            vector: parsedNode.vector,
-                            connections
-                        };
-                    }
-                    catch {
-                        // If not found in default directory either, try all noun type directories
-                        const directories = [
-                            this.personDir,
-                            this.placeDir,
-                            this.thingDir,
-                            this.eventDir,
-                            this.conceptDir,
-                            this.contentDir
-                        ];
-                        for (const dir of directories) {
-                            if (dir === nodeDir)
-                                continue; // Skip the already checked directory
-                            const dirFilePath = path.join(dir, `${id}.json`);
-                            try {
-                                await fs.promises.access(dirFilePath);
-                                // If found in this directory, use that path
-                                const data = await fs.promises.readFile(dirFilePath, 'utf8');
-                                const parsedNode = JSON.parse(data);
-                                // Convert serialized connections back to Map<number, Set<string>>
-                                const connections = new Map();
-                                for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                                    connections.set(Number(level), new Set(nodeIds));
-                                }
-                                return {
-                                    id: parsedNode.id,
-                                    vector: parsedNode.vector,
-                                    connections
-                                };
-                            }
-                            catch {
-                                // Continue to the next directory
-                            }
-                        }
-                        return null; // File doesn't exist in any directory
-                    }
-                }
-                return null; // File doesn't exist
-            }
-            const data = await fs.promises.readFile(filePath, 'utf8');
-            const parsedNode = JSON.parse(data);
-            // Convert serialized connections back to Map<number, Set<string>>
-            const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+            // Ignore EEXIST error, which means the directory already exists
+            if (error.code !== 'EEXIST') {
+                throw error;
             }
-            return {
-                id: parsedNode.id,
-                vector: parsedNode.vector,
-                connections
-            };
-        }
-        catch (error) {
-            console.error(`Failed to get node ${id}:`, error);
-            return null;
         }
     }
-    /**
-     * Get nodes by noun type
-     * @param nounType The noun type to filter by
-     * @returns Promise that resolves to an array of nodes of the specified noun type
-     */
-    async getNounsByNounType(nounType) {
-        await this.ensureInitialized();
-        try {
-            // Determine the directory based on the noun type
-            let dir;
-            switch (nounType) {
+    getNounPath(id, nounType) {
+        let typeDir = this.defaultDir;
+        if (nounType) {
+            switch (nounType.toLowerCase()) {
                 case 'person':
-                    dir = this.personDir;
+                    typeDir = this.personDir;
                     break;
                 case 'place':
-                    dir = this.placeDir;
+                    typeDir = this.placeDir;
                     break;
                 case 'thing':
-                    dir = this.thingDir;
+                    typeDir = this.thingDir;
                     break;
                 case 'event':
-                    dir = this.eventDir;
+                    typeDir = this.eventDir;
                     break;
                 case 'concept':
-                    dir = this.conceptDir;
+                    typeDir = this.conceptDir;
                     break;
                 case 'content':
-                    dir = this.contentDir;
+                    typeDir = this.contentDir;
                     break;
                 default:
-                    dir = this.defaultDir;
+                    typeDir = this.defaultDir;
             }
-            const nodes = [];
-            try {
-                const files = await fs.promises.readdir(dir);
-                const nodePromises = files
-                    .filter((file) => file.endsWith('.json'))
-                    .map((file) => {
-                    // Use the file path directly instead of getNode to avoid redundant searches
-                    return this.readNodeFromFile(path.join(dir, file));
-                });
-                const dirNodes = await Promise.all(nodePromises);
-                nodes.push(...dirNodes.filter((node) => node !== null));
-            }
-            catch (dirError) {
-                // If directory doesn't exist or can't be read, log a warning
-                console.warn(`Could not read directory for noun type ${nounType}:`, dirError);
-            }
-            return nodes;
-        }
-        catch (error) {
-            console.error(`Failed to get nodes for noun type ${nounType}:`, error);
-            throw new Error(`Failed to get nodes for noun type ${nounType}: ${error}`);
         }
+        return path.join(typeDir, `${id}.json`);
     }
-    /**
-     * Get all nodes from storage
-     */
-    async getAllNouns() {
-        await this.ensureInitialized();
-        try {
-            // Get all noun types
-            const nounTypes = [
-                'person',
-                'place',
-                'thing',
-                'event',
-                'concept',
-                'content',
-                'default'
-            ];
-            // Run searches in parallel for all noun types
-            const nodePromises = nounTypes.map((nounType) => this.getNounsByNounType(nounType));
-            const nodeArrays = await Promise.all(nodePromises);
-            // Combine all results
-            const allNodes = [];
-            for (const nodes of nodeArrays) {
-                allNodes.push(...nodes);
-            }
-            return allNodes;
-        }
-        catch (error) {
-            console.error('Failed to get all nodes:', error);
-            throw new Error(`Failed to get all nodes: ${error}`);
-        }
+    async saveNoun(noun) {
+        if (!this.isInitialized)
+            await this.init();
+        const nounType = noun.metadata?.noun;
+        const filePath = this.getNounPath(noun.id, nounType);
+        await this.ensureDirectoryExists(path.dirname(filePath));
+        await fs.promises.writeFile(filePath, JSON.stringify(noun, null, 2));
     }
-    /**
-     * Read a node from a file
-     */
-    async readNodeFromFile(filePath) {
-        try {
-            const data = await fs.promises.readFile(filePath, 'utf8');
-            const parsedNode = JSON.parse(data);
-            // Convert serialized connections back to Map<number, Set<string>>
-            const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(parsedNode.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+    async getNoun(id) {
+        if (!this.isInitialized)
+            await this.init();
+        const nounDirs = [
+            this.personDir,
+            this.placeDir,
+            this.thingDir,
+            this.eventDir,
+            this.conceptDir,
+            this.contentDir,
+            this.defaultDir
+        ];
+        for (const dir of nounDirs) {
+            const filePath = path.join(dir, `${id}.json`);
+            try {
+                const data = await fs.promises.readFile(filePath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error reading noun ${id}:`, error);
+                }
             }
-            return {
-                id: parsedNode.id,
-                vector: parsedNode.vector,
-                connections
-            };
-        }
-        catch (error) {
-            console.error(`Failed to read node from file ${filePath}:`, error);
-            return null;
         }
+        return null;
     }
-    /**
-     * Delete a node from storage
-     */
     async deleteNoun(id) {
-        await this.ensureInitialized();
-        try {
-            // Get the appropriate directory based on the node's metadata
-            const nodeDir = await this.getNodeDirectory(id);
-            const filePath = path.join(nodeDir, `${id}.json`);
-            // Check if a file exists before attempting to delete
+        if (!this.isInitialized)
+            await this.init();
+        const noun = await this.getNoun(id);
+        if (noun) {
+            const nounType = noun.metadata?.noun;
+            const filePath = this.getNounPath(id, nounType);
             try {
-                await fs.promises.access(filePath);
                 await fs.promises.unlink(filePath);
-                return; // File found and deleted
             }
-            catch {
-                // If the file doesn't exist in the expected directory, try the default directory
-                if (nodeDir !== this.defaultDir) {
-                    const defaultFilePath = path.join(this.defaultDir, `${id}.json`);
-                    try {
-                        await fs.promises.access(defaultFilePath);
-                        await fs.promises.unlink(defaultFilePath);
-                        return; // File found and deleted
-                    }
-                    catch {
-                        // If not found in default directory either, try all noun type directories
-                        const directories = [
-                            this.personDir,
-                            this.placeDir,
-                            this.thingDir,
-                            this.eventDir,
-                            this.conceptDir,
-                            this.contentDir
-                        ];
-                        for (const dir of directories) {
-                            if (dir === nodeDir)
-                                continue; // Skip the already checked directory
-                            const dirFilePath = path.join(dir, `${id}.json`);
-                            try {
-                                await fs.promises.access(dirFilePath);
-                                await fs.promises.unlink(dirFilePath);
-                                return; // File found and deleted
-                            }
-                            catch {
-                                // Continue to the next directory
-                            }
-                        }
-                        return; // File doesn't exist in any directory, nothing to delete
-                    }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error deleting noun file ${filePath}:`, error);
+                    throw error;
                 }
-                return; // File doesn't exist, nothing to delete
             }
         }
-        catch (error) {
-            console.error(`Failed to delete node ${id}:`, error);
-            throw new Error(`Failed to delete node ${id}: ${error}`);
-        }
-    }
-    /**
-     * Save an edge to storage
-     */
-    async saveVerb(verb) {
-        await this.ensureInitialized();
-        try {
-            // Convert connections Map to a serializable format
-            const serializableEdge = {
-                ...verb,
-                connections: this.mapToObject(verb.connections, (set) => Array.from(set))
-            };
-            const filePath = path.join(this.verbsDir, `${verb.id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(serializableEdge, null, 2), 'utf8');
-        }
-        catch (error) {
-            console.error(`Failed to save edge ${verb.id}:`, error);
-            throw new Error(`Failed to save edge ${verb.id}: ${error}`);
-        }
     }
-    /**
-     * Get an edge from storage
-     */
-    async getVerb(id) {
-        await this.ensureInitialized();
-        try {
-            const filePath = path.join(this.verbsDir, `${id}.json`);
-            // Check if a file exists
+    async getAllNouns() {
+        if (!this.isInitialized)
+            await this.init();
+        const allNouns = [];
+        const nounDirs = [
+            this.personDir,
+            this.placeDir,
+            this.thingDir,
+            this.eventDir,
+            this.conceptDir,
+            this.contentDir,
+            this.defaultDir
+        ];
+        for (const dir of nounDirs) {
             try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return null; // File doesn't exist
+                const files = await fs.promises.readdir(dir);
+                for (const file of files) {
+                    if (file.endsWith('.json')) {
+                        const filePath = path.join(dir, file);
+                        const data = await fs.promises.readFile(filePath, 'utf-8');
+                        allNouns.push(JSON.parse(data));
+                    }
+                }
             }
-            const data = await fs.promises.readFile(filePath, 'utf8');
-            const parsedEdge = JSON.parse(data);
-            // Convert serialized connections back to Map<number, Set<string>>
-            const connections = new Map();
-            for (const [level, nodeIds] of Object.entries(parsedEdge.connections)) {
-                connections.set(Number(level), new Set(nodeIds));
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    console.error(`Error reading directory ${dir}:`, error);
+                }
             }
-            return {
-                id: parsedEdge.id,
-                vector: parsedEdge.vector,
-                connections,
-                sourceId: parsedEdge.sourceId,
-                targetId: parsedEdge.targetId,
-                type: parsedEdge.type,
-                weight: parsedEdge.weight,
-                metadata: parsedEdge.metadata
-            };
-        }
-        catch (error) {
-            console.error(`Failed to get edge ${id}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Get all edges from storage
-     */
-    async getAllVerbs() {
-        await this.ensureInitialized();
-        try {
-            const files = await fs.promises.readdir(this.verbsDir);
-            const edgePromises = files
-                .filter((file) => file.endsWith('.json'))
-                .map((file) => {
-                const id = path.basename(file, '.json');
-                return this.getVerb(id);
-            });
-            const edges = await Promise.all(edgePromises);
-            return edges.filter((edge) => edge !== null);
-        }
-        catch (error) {
-            console.error('Failed to get all edges:', error);
-            throw new Error(`Failed to get all edges: ${error}`);
-        }
-    }
-    /**
-     * Get edges by source node ID
-     */
-    async getVerbsBySource(sourceId) {
-        await this.ensureInitialized();
-        try {
-            const allEdges = await this.getAllVerbs();
-            return allEdges.filter((edge) => edge.sourceId === sourceId);
-        }
-        catch (error) {
-            console.error(`Failed to get edges by source ${sourceId}:`, error);
-            throw new Error(`Failed to get edges by source ${sourceId}: ${error}`);
-        }
-    }
-    /**
-     * Get edges by target node ID
-     */
-    async getVerbsByTarget(targetId) {
-        await this.ensureInitialized();
-        try {
-            const allEdges = await this.getAllVerbs();
-            return allEdges.filter((edge) => edge.targetId === targetId);
-        }
-        catch (error) {
-            console.error(`Failed to get edges by target ${targetId}:`, error);
-            throw new Error(`Failed to get edges by target ${targetId}: ${error}`);
         }
+        return allNouns;
     }
     /**
-     * Get edges by type
+     * Get nouns by noun type
+     * @param nounType The noun type to filter by
+     * @returns Promise that resolves to an array of nouns of the specified noun type
      */
-    async getVerbsByType(type) {
-        await this.ensureInitialized();
-        try {
-            const allEdges = await this.getAllVerbs();
-            return allEdges.filter((edge) => edge.type === type);
-        }
-        catch (error) {
-            console.error(`Failed to get edges by type ${type}:`, error);
-            throw new Error(`Failed to get edges by type ${type}: ${error}`);
+    async getNounsByNounType(nounType) {
+        if (!this.isInitialized)
+            await this.init();
+        let typeDir;
+        switch (nounType.toLowerCase()) {
+            case 'person':
+                typeDir = this.personDir;
+                break;
+            case 'place':
+                typeDir = this.placeDir;
+                break;
+            case 'thing':
+                typeDir = this.thingDir;
+                break;
+            case 'event':
+                typeDir = this.eventDir;
+                break;
+            case 'concept':
+                typeDir = this.conceptDir;
+                break;
+            case 'content':
+                typeDir = this.contentDir;
+                break;
+            default:
+                typeDir = this.defaultDir;
         }
-    }
-    /**
-     * Delete an edge from storage
-     */
-    async deleteVerb(id) {
-        await this.ensureInitialized();
+        const nouns = [];
         try {
-            const filePath = path.join(this.verbsDir, `${id}.json`);
-            // Check if a file exists before attempting to delete
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return; // File doesn't exist, nothing to delete
+            const files = await fs.promises.readdir(typeDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(typeDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    nouns.push(JSON.parse(data));
+                }
             }
-            await fs.promises.unlink(filePath);
         }
         catch (error) {
-            console.error(`Failed to delete edge ${id}:`, error);
-            throw new Error(`Failed to delete edge ${id}: ${error}`);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading directory ${typeDir}:`, error);
+            }
         }
+        return nouns;
     }
-    /**
-     * Save metadata to storage
-     */
-    async saveMetadata(id, metadata) {
-        await this.ensureInitialized();
-        try {
-            const filePath = path.join(this.metadataDir, `${id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2), 'utf8');
-        }
-        catch (error) {
-            console.error(`Failed to save metadata for ${id}:`, error);
-            throw new Error(`Failed to save metadata for ${id}: ${error}`);
-        }
+    async saveVerb(verb) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.verbsDir, `${verb.id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(verb, null, 2));
     }
     /**
-     * Get metadata from storage
+     * Get a verb by its ID
+     * @param id The ID of the verb to retrieve
+     * @returns Promise that resolves to the verb or null if not found
      */
-    async getMetadata(id) {
-        await this.ensureInitialized();
+    async getVerb(id) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.verbsDir, `${id}.json`);
         try {
-            const filePath = path.join(this.metadataDir, `${id}.json`);
-            // Check if a file exists
-            try {
-                await fs.promises.access(filePath);
-            }
-            catch {
-                return null; // File doesn't exist
-            }
-            const data = await fs.promises.readFile(filePath, 'utf8');
+            const data = await fs.promises.readFile(filePath, 'utf-8');
             return JSON.parse(data);
         }
         catch (error) {
-            console.error(`Failed to get metadata for ${id}:`, error);
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading verb ${id}:`, error);
+            }
             return null;
         }
     }
-    /**
-     * Clear all data from storage
-     */
-    async clear() {
-        await this.ensureInitialized();
-        try {
-            // Delete and recreate the nodes, edges, and metadata directories
-            await this.deleteDirectory(this.nounsDir);
-            await this.deleteDirectory(this.verbsDir);
-            await this.deleteDirectory(this.metadataDir);
-            await this.ensureDirectoryExists(this.nounsDir);
-            await this.ensureDirectoryExists(this.verbsDir);
-            await this.ensureDirectoryExists(this.metadataDir);
-            // Create noun type directories
-            await this.ensureDirectoryExists(this.personDir);
-            await this.ensureDirectoryExists(this.placeDir);
-            await this.ensureDirectoryExists(this.thingDir);
-            await this.ensureDirectoryExists(this.eventDir);
-            await this.ensureDirectoryExists(this.conceptDir);
-            await this.ensureDirectoryExists(this.contentDir);
-            await this.ensureDirectoryExists(this.defaultDir);
-        }
-        catch (error) {
-            console.error('Failed to clear storage:', error);
-            throw new Error(`Failed to clear storage: ${error}`);
-        }
+    async getVerbsBySource(sourceId) {
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter((verb) => verb.sourceId === sourceId);
     }
     /**
-     * Ensure the storage adapter is initialized
+     * Get verbs by target ID
+     * @param targetId The target ID to filter by
+     * @returns Promise that resolves to an array of verbs with the specified target ID
      */
-    async ensureInitialized() {
-        if (!this.isInitialized) {
+    async getVerbsByTarget(targetId) {
+        if (!this.isInitialized)
             await this.init();
-        }
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter((verb) => verb.targetId === targetId);
     }
     /**
-     * Ensure a directory exists, creating it if necessary
+     * Get verbs by type
+     * @param type The verb type to filter by
+     * @returns Promise that resolves to an array of verbs of the specified type
      */
-    async ensureDirectoryExists(dirPath) {
-        try {
-            await fs.promises.access(dirPath);
-        }
-        catch {
-            // Directory doesn't exist, create it
-            await fs.promises.mkdir(dirPath, { recursive: true });
-        }
+    async getVerbsByType(type) {
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = await this.getAllVerbs();
+        return allVerbs.filter((verb) => verb.type === type);
     }
-    /**
-     * Delete a directory and all its contents recursively
-     */
-    async deleteDirectory(dirPath) {
+    async getAllVerbs() {
+        if (!this.isInitialized)
+            await this.init();
+        const allVerbs = [];
         try {
-            const files = await fs.promises.readdir(dirPath);
+            const files = await fs.promises.readdir(this.verbsDir);
             for (const file of files) {
-                const filePath = path.join(dirPath, file);
-                const stats = await fs.promises.stat(filePath);
-                if (stats.isDirectory()) {
-                    // Recursively delete subdirectories
-                    await this.deleteDirectory(filePath);
-                }
-                else {
-                    // Delete files
-                    await fs.promises.unlink(filePath);
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.verbsDir, file);
+                    const data = await fs.promises.readFile(filePath, 'utf-8');
+                    allVerbs.push(JSON.parse(data));
                 }
             }
-            // After all contents are deleted, remove the directory itself
-            await fs.promises.rmdir(dirPath);
         }
         catch (error) {
-            // If the directory doesn't exist, that's fine
             if (error.code !== 'ENOENT') {
-                throw error;
+                console.error(`Error reading verbs directory ${this.verbsDir}:`, error);
             }
         }
+        return allVerbs;
     }
-    /**
-     * Count the number of JSON files in a directory
-     */
-    async countFilesInDirectory(dirPath) {
+    async deleteVerb(id) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.verbsDir, `${id}.json`);
         try {
-            const files = await fs.promises.readdir(dirPath);
-            return files.filter((file) => file.endsWith('.json')).length;
+            await fs.promises.unlink(filePath);
         }
         catch (error) {
-            // If the directory doesn't exist, return 0
-            if (error.code === 'ENOENT') {
-                return 0;
+            if (error.code !== 'ENOENT') {
+                console.error(`Error deleting verb file ${filePath}:`, error);
+                throw error;
             }
-            throw error;
         }
     }
     /**
-     * Convert a Map to a plain object for serialization
+     * Save metadata for an entity
+     * @param id The ID of the entity
+     * @param metadata The metadata to save
      */
-    mapToObject(map, valueTransformer = (v) => v) {
-        const obj = {};
-        for (const [key, value] of map.entries()) {
-            obj[key.toString()] = valueTransformer(value);
-        }
-        return obj;
+    async saveMetadata(id, metadata) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.metadataDir, `${id}.json`);
+        await fs.promises.writeFile(filePath, JSON.stringify(metadata, null, 2));
     }
     /**
-     * Get the appropriate directory for a node based on its metadata
+     * Get metadata for an entity
+     * @param id The ID of the entity
+     * @returns Promise that resolves to the metadata or null if not found
      */
-    async getNodeDirectory(id) {
+    async getMetadata(id) {
+        if (!this.isInitialized)
+            await this.init();
+        const filePath = path.join(this.metadataDir, `${id}.json`);
         try {
-            // Try to get the metadata for the node
-            const metadata = await this.getMetadata(id);
-            // If metadata exists and has a noun field, use the corresponding directory
-            if (metadata && metadata.noun) {
-                switch (metadata.noun) {
-                    case 'person':
-                        return this.personDir;
-                    case 'place':
-                        return this.placeDir;
-                    case 'thing':
-                        return this.thingDir;
-                    case 'event':
-                        return this.eventDir;
-                    case 'concept':
-                        return this.conceptDir;
-                    case 'content':
-                        return this.contentDir;
-                    default:
-                        return this.defaultDir;
-                }
-            }
-            // If no metadata or no noun field, use the default directory
-            return this.defaultDir;
+            const data = await fs.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
         }
         catch (error) {
-            // If there's an error getting the metadata, use the default directory
-            return this.defaultDir;
+            if (error.code !== 'ENOENT') {
+                console.error(`Error reading metadata for ${id}:`, error);
+            }
+            return null;
         }
     }
-    /**
-     * Get information about storage usage and capacity
-     */
+    async clear() {
+        if (!this.isInitialized)
+            await this.init();
+        await fs.promises.rm(this.rootDir, { recursive: true, force: true });
+        this.isInitialized = false; // Reset state
+        await this.init(); // Re-create directories
+    }
     async getStorageStatus() {
-        await this.ensureInitialized();
-        try {
-            // Calculate the total size of all files in the storage directories
-            let totalSize = 0;
-            // Helper function to calculate directory size
-            const calculateDirSize = async (dirPath) => {
-                let size = 0;
-                try {
-                    const files = await fs.promises.readdir(dirPath);
-                    for (const file of files) {
-                        const filePath = path.join(dirPath, file);
-                        const stats = await fs.promises.stat(filePath);
-                        if (stats.isDirectory()) {
-                            size += await calculateDirSize(filePath);
-                        }
-                        else {
-                            size += stats.size;
-                        }
+        if (!this.isInitialized)
+            await this.init();
+        const calculateSize = async (dirPath) => {
+            let size = 0;
+            try {
+                const files = await fs.promises.readdir(dirPath, {
+                    withFileTypes: true
+                });
+                for (const file of files) {
+                    const fullPath = path.join(dirPath, file.name);
+                    if (file.isDirectory()) {
+                        size += await calculateSize(fullPath);
                     }
-                }
-                catch (error) {
-                    console.warn(`Error calculating size for ${dirPath}:`, error);
-                }
-                return size;
-            };
-            // Calculate size for each directory
-            const nodesDirSize = await calculateDirSize(this.nounsDir);
-            const edgesDirSize = await calculateDirSize(this.verbsDir);
-            const metadataDirSize = await calculateDirSize(this.metadataDir);
-            // Calculate sizes of noun type directories
-            const personDirSize = await calculateDirSize(this.personDir);
-            const placeDirSize = await calculateDirSize(this.placeDir);
-            const thingDirSize = await calculateDirSize(this.thingDir);
-            const eventDirSize = await calculateDirSize(this.eventDir);
-            const conceptDirSize = await calculateDirSize(this.conceptDir);
-            const contentDirSize = await calculateDirSize(this.contentDir);
-            const defaultDirSize = await calculateDirSize(this.defaultDir);
-            // Note: The noun type directories are subdirectories of the nodes directory,
-            // so their sizes are already included in nodesDirSize.
-            // We don't need to add them again to avoid double counting.
-            totalSize = nodesDirSize + edgesDirSize + metadataDirSize;
-            // Get filesystem information
-            let quota = null;
-            let details = {
-                nounTypes: {
-                    person: {
-                        size: personDirSize,
-                        count: await this.countFilesInDirectory(this.personDir)
-                    },
-                    place: {
-                        size: placeDirSize,
-                        count: await this.countFilesInDirectory(this.placeDir)
-                    },
-                    thing: {
-                        size: thingDirSize,
-                        count: await this.countFilesInDirectory(this.thingDir)
-                    },
-                    event: {
-                        size: eventDirSize,
-                        count: await this.countFilesInDirectory(this.eventDir)
-                    },
-                    concept: {
-                        size: conceptDirSize,
-                        count: await this.countFilesInDirectory(this.conceptDir)
-                    },
-                    content: {
-                        size: contentDirSize,
-                        count: await this.countFilesInDirectory(this.contentDir)
-                    },
-                    default: {
-                        size: defaultDirSize,
-                        count: await this.countFilesInDirectory(this.defaultDir)
+                    else {
+                        const stats = await fs.promises.stat(fullPath);
+                        size += stats.size;
                     }
                 }
-            };
-            try {
-                // Try to get disk space information
-                const stats = await fs.promises.statfs(this.rootDir);
-                if (stats) {
-                    const availableSpace = stats.bavail * stats.bsize;
-                    const totalSpace = stats.blocks * stats.bsize;
-                    quota = totalSpace;
-                    details = {
-                        availableSpace,
-                        totalSpace,
-                        freePercentage: (availableSpace / totalSpace) * 100
-                    };
-                }
             }
             catch (error) {
-                console.warn('Unable to get filesystem stats:', error);
-                // If statfs is not available, try to use df command on Unix-like systems
-                try {
-                    const { exec } = await Promise.resolve().then(function () { return _child_processShim; });
-                    const util = await Promise.resolve().then(function () { return _utilShim$1; });
-                    const execPromise = util.promisify(exec);
-                    const { stdout } = await execPromise(`df -k "${this.rootDir}"`);
-                    const lines = stdout.trim().split('\n');
-                    if (lines.length > 1) {
-                        const parts = lines[1].split(/\s+/);
-                        if (parts.length >= 4) {
-                            const totalKB = parseInt(parts[1], 10);
-                            const usedKB = parseInt(parts[2], 10);
-                            const availableKB = parseInt(parts[3], 10);
-                            quota = totalKB * 1024;
-                            details = {
-                                availableSpace: availableKB * 1024,
-                                totalSpace: totalKB * 1024,
-                                freePercentage: (availableKB / totalKB) * 100
-                            };
-                        }
-                    }
-                }
-                catch (dfError) {
-                    console.warn('Unable to get disk space using df command:', dfError);
+                if (error.code !== 'ENOENT') {
+                    console.error(`Could not calculate size for ${dirPath}:`, error);
                 }
             }
-            return {
-                type: 'filesystem',
-                used: totalSize,
-                quota,
-                details
-            };
-        }
-        catch (error) {
-            console.error('Failed to get storage status:', error);
-            return {
-                type: 'filesystem',
-                used: 0,
-                quota: null,
-                details: { error: String(error) }
-            };
-        }
+            return size;
+        };
+        const totalSize = await calculateSize(this.rootDir);
+        const nouns = await this.getAllNouns();
+        const verbs = await this.getAllVerbs();
+        return {
+            type: 'FileSystem',
+            used: totalSize,
+            quota: null, // File system quota is not easily available from Node.js
+            details: {
+                rootDir: this.rootDir,
+                nounCount: nouns.length,
+                verbCount: verbs.length
+            }
+        };
     }
 }
 
@@ -14193,20 +13951,15 @@ class BrainyMCPService {
     }
 }
 
-/**
- * OPFS BrainyData
- * A vector database using HNSW indexing with Origin Private File System storage
- */
-// Import unified text encoding utilities first to ensure they're available
-// Apply the TensorFlow.js platform patch if needed
-applyTensorFlowPatch();
-
 // Make Buffer available globally
 if (typeof window !== 'undefined' && typeof globalThis.Buffer === 'undefined') {
   globalThis.Buffer = buffer$1.Buffer;
 }
-// Apply the TensorFlow.js platform patch if needed
-applyTensorFlowPatch();
+/**
+ * Unified entry point for Brainy
+ * This file exports everything from index.ts
+ * Environment detection is handled here and made available to all components
+ */
 // Export environment information
 const environment = {
     isBrowser: typeof window !== 'undefined',
@@ -22312,7 +22065,7 @@ class PlatformNode {
         this.util = require$$1;
         // According to the spec, the built-in encoder can do only UTF-8 encoding.
         // https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder/TextEncoder
-        this.textEncoder = new TextEncoder();
+        this.textEncoder = new this.util.TextEncoder();
     }
     fetch(path, requestInits) {
         if (env().global.fetch != null) {
@@ -87531,9 +87284,5 @@ var universalSentenceEncoder_esm = /*#__PURE__*/Object.freeze({
 	version: version
 });
 
-var _child_processShim = /*#__PURE__*/Object.freeze({
-	__proto__: null
-});
-
 export { AugmentationType, BrainyData, BrainyMCPAdapter, BrainyMCPService, ExecutionMode$1 as ExecutionMode, FileSystemStorage, FileSystemStorageAugmentation, HNSWIndex, HNSWIndexOptimized, MCPAugmentationToolset, MCPRequestType, MCP_VERSION, MemoryStorage, MemoryStorageAugmentation, NounType, OPFSStorage, OPFSStorageAugmentation, Pipeline, S3CompatibleStorage as R2Storage, S3CompatibleStorage, SequentialPipeline, ServerSearchActivationAugmentation, ServerSearchConduitAugmentation, StreamlinedExecutionMode, UniversalSentenceEncoder$1 as UniversalSentenceEncoder, VerbType, WebRTCConduitAugmentation, WebSocketConduitAugmentation, addWebSocketSupport, areWebWorkersAvailable, areWorkerThreadsAvailable, areWorkerThreadsAvailableSync, augmentationPipeline$1 as augmentationPipeline, availableAugmentations, cleanupWorkerPools, cosineDistance$1 as cosineDistance, createAugmentationRegistryPlugin, createAugmentationRegistryRollupPlugin, createConduitAugmentation, createEmbeddingFunction, createMemoryAugmentation, createPipeline, createSenseAugmentation, createServerSearchAugmentations, createStorage, createStreamingPipeline, createTensorFlowEmbeddingFunction, createThreadedEmbeddingFunction, defaultEmbeddingFunction, dotProductDistance, environment, euclideanDistance, executeAugmentation, executeByType, executeInThread, executeSingle, executeStreamlined, getAugmentationsByType, initializeAugmentationPipeline, isBrowser$1 as isBrowser, isNode, isThreadingAvailable, isThreadingAvailableAsync, isWebWorker, loadAugmentationModule, loadAugmentationsFromModules, manhattanDistance, pipeline, processStaticData, processStreamingData, registerAugmentation, sequentialPipeline, setAugmentationEnabled };
 //# sourceMappingURL=unified.js.map