@soulcraft/brainy 0.9.23 → 0.9.26

package/README.md

@@ -3,10 +3,10 @@
 <br/><br/>
 
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Node.js](https://img.shields.io/badge/node-%3E%3D24.0.0-brightgreen.svg)](https://nodejs.org/)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D23.0.0-brightgreen.svg)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.1.6-blue.svg)](https://www.typescriptlang.org/)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
-[![npm](https://img.shields.io/badge/npm-v0.9.23-blue.svg)](https://www.npmjs.com/package/@soulcraft/brainy)
+[![npm](https://img.shields.io/badge/npm-v0.9.26-blue.svg)](https://www.npmjs.com/package/@soulcraft/brainy)
 
 [//]: # ([![Cartographer]&#40;https://img.shields.io/badge/Cartographer-Official%20Standard-brightgreen&#41;]&#40;https://github.com/sodal-project/cartographer&#41;)
 

package/dist/brainy.js

@@ -2900,6 +2900,19 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
         this.use = null;
         this.backend = 'cpu'; // Default to CPU
     }
+    /**
+     * Add polyfills and patches for TensorFlow.js compatibility
+     * This addresses issues with TensorFlow.js in Node.js environments
+     */
+    addNodeCompatibilityPolyfills() {
+        // Only apply in Node.js environment
+        if (typeof process === 'undefined' ||
+            !process.versions ||
+            !process.versions.node) {
+            return;
+        }
+        // No compatibility patches needed - TensorFlow.js now works correctly with Node.js 24+
+    }
     /**
      * Initialize the embedding model
      */
@@ -2916,6 +2929,8 @@ let UniversalSentenceEncoder$1 = class UniversalSentenceEncoder {
                 }
                 originalWarn(message, ...optionalParams);
             };
+            // Add polyfills for TensorFlow.js compatibility
+            this.addNodeCompatibilityPolyfills();
             // TensorFlow.js will use its default EPSILON value
             // Dynamically import TensorFlow.js core module and backends
             // Use type assertions to tell TypeScript these modules exist
@@ -9312,9 +9327,42 @@ class BrainyData {
     }
 }
 
-// We'll dynamically import Node.js built-in modules
+// Import Node.js built-in modules
+// Using require for compatibility with Node.js
 let fs;
 let path;
+// Initialize these modules immediately if in Node.js environment
+if (typeof process !== 'undefined' &&
+    process.versions &&
+    process.versions.node) {
+    try {
+        // Use require for Node.js built-in modules
+        fs = require('fs');
+        path = require('path');
+        // Verify that path has the required methods
+        if (!path || typeof path.resolve !== 'function') {
+            throw new Error('path module is missing required methods');
+        }
+    }
+    catch (e) {
+        console.warn('Failed to load Node.js modules with require:', e);
+        // Try using dynamic import as a fallback
+        try {
+            // Use a synchronous approach to ensure modules are loaded before continuing
+            const pathModule = require('node:path');
+            const fsModule = require('node:fs');
+            path = pathModule;
+            fs = fsModule;
+            // Verify that path has the required methods
+            if (!path || typeof path.resolve !== 'function') {
+                throw new Error('path module from node:path is missing required methods');
+            }
+        }
+        catch (nodeImportError) {
+            console.warn('Failed to load Node.js modules with node: prefix:', nodeImportError);
+        }
+    }
+}
 // Constants for directory and file names
 const ROOT_DIR = 'brainy-data';
 const NOUNS_DIR = 'nouns';
@@ -9355,32 +9403,91 @@ class FileSystemStorage {
             return;
         }
         try {
-            // Dynamically import Node.js built-in modules
-            try {
-                // Import the modules
-                const fsModule = await Promise.resolve().then(function () { return _fsShim$1; });
-                const pathModule = await Promise.resolve().then(function () { return _pathShim$1; });
-                // Assign to our module-level variables
-                fs = fsModule.default || fsModule;
-                path = pathModule.default || pathModule;
-                // Now set up the directory paths
-                const rootDir = this.rootDir || process.cwd();
-                this.rootDir = path.resolve(rootDir, ROOT_DIR);
-                this.nounsDir = path.join(this.rootDir, NOUNS_DIR);
-                this.verbsDir = path.join(this.rootDir, VERBS_DIR);
-                this.metadataDir = path.join(this.rootDir, METADATA_DIR);
-                // Set up noun type directory paths
-                this.personDir = path.join(this.nounsDir, PERSON_DIR);
-                this.placeDir = path.join(this.nounsDir, PLACE_DIR);
-                this.thingDir = path.join(this.nounsDir, THING_DIR);
-                this.eventDir = path.join(this.nounsDir, EVENT_DIR);
-                this.conceptDir = path.join(this.nounsDir, CONCEPT_DIR);
-                this.contentDir = path.join(this.nounsDir, CONTENT_DIR);
-                this.defaultDir = path.join(this.nounsDir, DEFAULT_DIR);
-            }
-            catch (importError) {
-                throw new Error(`Failed to import Node.js modules: ${importError}. This adapter requires a Node.js environment.`);
+            // 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 require
+                    async () => {
+                        console.log('Attempting to load Node.js modules with require()');
+                        const fsModule = require('fs');
+                        const pathModule = require('path');
+                        if (!pathModule || typeof pathModule.resolve !== 'function') {
+                            throw new Error('path.resolve is not a function after require()');
+                        }
+                        return { fs: fsModule, path: pathModule };
+                    },
+                    // Attempt 2: Use require with node: prefix
+                    async () => {
+                        console.log('Attempting to load Node.js modules with require("node:...")');
+                        const fsModule = require('node:fs');
+                        const pathModule = require('node:path');
+                        if (!pathModule || typeof pathModule.resolve !== 'function') {
+                            throw new Error('path.resolve is not a function after require("node:path")');
+                        }
+                        return { fs: fsModule, path: pathModule };
+                    },
+                    // Attempt 3: Use dynamic import
+                    async () => {
+                        console.log('Attempting to load Node.js modules with dynamic import');
+                        const fsModule = await Promise.resolve().then(function () { return _fsShim$1; });
+                        const pathModule = await Promise.resolve().then(function () { return _pathShim$1; });
+                        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 4: 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);
+            this.nounsDir = path.join(this.rootDir, NOUNS_DIR);
+            this.verbsDir = path.join(this.rootDir, VERBS_DIR);
+            this.metadataDir = path.join(this.rootDir, METADATA_DIR);
+            // Set up noun type directory paths
+            this.personDir = path.join(this.nounsDir, PERSON_DIR);
+            this.placeDir = path.join(this.nounsDir, PLACE_DIR);
+            this.thingDir = path.join(this.nounsDir, THING_DIR);
+            this.eventDir = path.join(this.nounsDir, EVENT_DIR);
+            this.conceptDir = path.join(this.nounsDir, CONCEPT_DIR);
+            this.contentDir = path.join(this.nounsDir, CONTENT_DIR);
+            this.defaultDir = path.join(this.nounsDir, DEFAULT_DIR);
             // Create directories if they don't exist
             await this.ensureDirectoryExists(this.rootDir);
             await this.ensureDirectoryExists(this.nounsDir);