@soulcraft/brainy 3.6.0 → 3.7.1

package/dist/augmentations/auditLogAugmentation.js

@@ -3,7 +3,7 @@
  * Provides comprehensive audit trail for all Brainy operations
  */
 import { BaseAugmentation } from './brainyAugmentation.js';
-import { createHash } from 'node:crypto';
+import { createHash } from '../universal/crypto.js';
 /**
  * Audit Log Augmentation
  */

package/dist/augmentations/discovery/localDiscovery.d.ts

@@ -3,6 +3,8 @@
  *
  * Discovers augmentations installed locally in node_modules
  * and built-in augmentations that ship with Brainy
+ *
+ * NOTE: This is a Node.js-only feature that requires filesystem access
  */
 import { AugmentationManifest } from '../manifest.js';
 export interface LocalAugmentation {

package/dist/augmentations/discovery/localDiscovery.js

@@ -3,9 +3,27 @@
  *
  * Discovers augmentations installed locally in node_modules
  * and built-in augmentations that ship with Brainy
+ *
+ * NOTE: This is a Node.js-only feature that requires filesystem access
  */
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+// Node.js modules - dynamically imported to avoid bundler issues
+let fs = null;
+let path = null;
+// Load Node.js modules if available
+if (typeof window === 'undefined') {
+    try {
+        fs = await import('node:fs');
+        path = await import('node:path');
+    }
+    catch (e) {
+        // Will throw error in methods if not available
+    }
+}
+// Create compatibility layer for sync methods
+const existsSync = fs?.existsSync || (() => { throw new Error('Filesystem not available'); });
+const readdirSync = fs?.readdirSync || (() => { throw new Error('Filesystem not available'); });
+const readFileSync = fs?.readFileSync || (() => { throw new Error('Filesystem not available'); });
+const join = path?.join || ((...args) => args.join('/'));
 /**
  * Discovers augmentations installed locally
  */

package/dist/critical/model-guardian.js

@@ -10,9 +10,6 @@
  * 3. Model MUST produce consistent 384-dim embeddings
  * 4. System MUST fail fast if model unavailable in production
  */
-import { existsSync } from 'node:fs';
-import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
 import { env } from '@huggingface/transformers';
 // CRITICAL: These values MUST NEVER CHANGE
 const CRITICAL_MODEL_CONFIG = {
@@ -87,8 +84,8 @@ export class ModelGuardian {
             this.configureTransformers();
             return;
         }
-        // Step 2: In production, FAIL FAST
-        if (process.env.NODE_ENV === 'production' && !process.env.BRAINY_ALLOW_RUNTIME_DOWNLOAD) {
+        // Step 2: In production, FAIL FAST (Node.js only)
+        if (typeof window === 'undefined' && process.env.NODE_ENV === 'production' && !process.env.BRAINY_ALLOW_RUNTIME_DOWNLOAD) {
             throw new Error('🚨 CRITICAL FAILURE: Transformer model not found in production!\n' +
                 'The model is REQUIRED for Brainy to function.\n' +
                 'Users CANNOT access their data without it.\n' +
@@ -124,7 +121,16 @@ export class ModelGuardian {
      * Verify the local model files exist and are correct
      */
     async verifyLocalModel() {
-        const modelBasePath = join(this.modelPath, ...CRITICAL_MODEL_CONFIG.modelName.split('/'));
+        // Browser doesn't have local file access
+        if (typeof window !== 'undefined') {
+            console.log('⚠️ Model verification skipped in browser environment');
+            return false;
+        }
+        // Dynamically import Node.js modules
+        const fs = await import('node:fs');
+        const fsPromises = await import('node:fs/promises');
+        const path = await import('node:path');
+        const modelBasePath = path.join(this.modelPath, ...CRITICAL_MODEL_CONFIG.modelName.split('/'));
         console.log(`🔍 Debug: Checking model at path: ${modelBasePath}`);
         console.log(`🔍 Debug: Model path components: ${this.modelPath} + ${CRITICAL_MODEL_CONFIG.modelName.split('/')}`);
         // Check critical files
@@ -134,15 +140,15 @@ export class ModelGuardian {
             'config.json'
         ];
         for (const file of criticalFiles) {
-            const filePath = join(modelBasePath, file);
+            const filePath = path.join(modelBasePath, file);
             console.log(`🔍 Debug: Checking file: ${filePath}`);
-            if (!existsSync(filePath)) {
+            if (!fs.existsSync(filePath)) {
                 console.log(`❌ Missing critical file: ${file} at ${filePath}`);
                 return false;
             }
             // Verify size for critical files
             if (CRITICAL_MODEL_CONFIG.modelSize[file]) {
-                const stats = await stat(filePath);
+                const stats = await fsPromises.stat(filePath);
                 const expectedSize = CRITICAL_MODEL_CONFIG.modelSize[file];
                 if (Math.abs(stats.size - expectedSize) > 1000) { // Allow 1KB variance
                     console.error(`❌ CRITICAL: Model file size mismatch!\n` +
@@ -220,22 +226,34 @@ export class ModelGuardian {
      * Detect where models should be stored
      */
     detectModelPath() {
-        const candidates = [
-            process.env.BRAINY_MODELS_PATH,
-            './models',
-            join(process.cwd(), 'models'),
-            join(process.env.HOME || '', '.brainy', 'models'),
-            '/opt/models', // Lambda/container path
-            env.cacheDir
-        ];
-        for (const path of candidates) {
-            if (path && existsSync(path)) {
-                const modelPath = join(path, ...CRITICAL_MODEL_CONFIG.modelName.split('/'));
-                if (existsSync(join(modelPath, 'onnx', 'model.onnx'))) {
-                    return path; // Return the models directory, not its parent
+        // Browser always uses default path
+        if (typeof window !== 'undefined') {
+            return './models';
+        }
+        // Use require for synchronous access in Node.js
+        try {
+            const fs = require('node:fs');
+            const path = require('node:path');
+            const candidates = [
+                process.env.BRAINY_MODELS_PATH,
+                './models',
+                path.join(process.cwd(), 'models'),
+                path.join(process.env.HOME || '', '.brainy', 'models'),
+                '/opt/models', // Lambda/container path
+                env.cacheDir
+            ];
+            for (const candidatePath of candidates) {
+                if (candidatePath && fs.existsSync(candidatePath)) {
+                    const modelPath = path.join(candidatePath, ...CRITICAL_MODEL_CONFIG.modelName.split('/'));
+                    if (fs.existsSync(path.join(modelPath, 'onnx', 'model.onnx'))) {
+                        return candidatePath; // Return the models directory, not its parent
+                    }
                 }
             }
         }
+        catch (e) {
+            // If Node.js modules not available, return default
+        }
         // Default
         return './models';
     }

package/dist/universal/fs.js

@@ -59,13 +59,44 @@ class NodeFS {
         await nodeFs.access(path, mode);
     }
 }
+// Browser-safe no-op implementation
+class BrowserFS {
+    async readFile(path, encoding = 'utf-8') {
+        throw new Error('File system operations not available in browser. Use OPFS, Memory, or S3 storage adapters instead.');
+    }
+    async writeFile(path, data, encoding = 'utf-8') {
+        throw new Error('File system operations not available in browser. Use OPFS, Memory, or S3 storage adapters instead.');
+    }
+    async mkdir(path, options = { recursive: true }) {
+        throw new Error('File system operations not available in browser. Use OPFS, Memory, or S3 storage adapters instead.');
+    }
+    async exists(path) {
+        return false; // Always return false in browser
+    }
+    async readdir(path, options) {
+        if (options?.withFileTypes) {
+            return [];
+        }
+        return [];
+    }
+    async unlink(path) {
+        throw new Error('File system operations not available in browser. Use OPFS, Memory, or S3 storage adapters instead.');
+    }
+    async stat(path) {
+        throw new Error('File system operations not available in browser. Use OPFS, Memory, or S3 storage adapters instead.');
+    }
+    async access(path, mode) {
+        throw new Error('File system operations not available in browser. Use OPFS, Memory, or S3 storage adapters instead.');
+    }
+}
 // Create the appropriate filesystem implementation
 let fsImpl;
 if (isNode() && nodeFs) {
     fsImpl = new NodeFS();
 }
 else {
-    throw new Error('File system operations not available. Framework bundlers should provide fs polyfills or use storage adapters like OPFS, Memory, or S3.');
+    // Use browser-safe no-op implementation instead of throwing
+    fsImpl = new BrowserFS();
 }
 // Export the filesystem operations
 export const readFile = fsImpl.readFile.bind(fsImpl);

package/dist/utils/embedding.js

@@ -161,8 +161,8 @@ export class TransformerEmbedding {
                 // Use dynamic import instead of require for ES modules compatibility
                 const { createRequire } = await import('module');
                 const require = createRequire(import.meta.url);
-                const path = require('path');
-                const fs = require('fs');
+                const path = require('node:path');
+                const fs = require('node:fs');
                 // Try to resolve the package location
                 try {
                     const brainyPackagePath = require.resolve('@soulcraft/brainy/package.json');

package/dist/utils/paramValidation.js

@@ -5,7 +5,31 @@
  * Only enforces universal truths, learns everything else
  */
 import { NounType, VerbType } from '../types/graphTypes.js';
-import * as os from 'node:os';
+// Dynamic import for Node.js os module
+let os = null;
+if (typeof window === 'undefined') {
+    try {
+        os = await import('node:os');
+    }
+    catch (e) {
+        // OS module not available
+    }
+}
+// Browser-safe memory detection
+const getSystemMemory = () => {
+    if (os) {
+        return os.totalmem();
+    }
+    // Browser fallback: assume 4GB
+    return 4 * 1024 * 1024 * 1024;
+};
+const getAvailableMemory = () => {
+    if (os) {
+        return os.freemem();
+    }
+    // Browser fallback: assume 2GB available
+    return 2 * 1024 * 1024 * 1024;
+};
 /**
  * Auto-configured limits based on system resources
  * These adapt to available memory and observed performance
@@ -16,8 +40,8 @@ class ValidationConfig {
         this.avgQueryTime = 0;
         this.queryCount = 0;
         // Auto-configure based on system resources
-        const totalMemory = os.totalmem();
-        const availableMemory = os.freemem();
+        const totalMemory = getSystemMemory();
+        const availableMemory = getAvailableMemory();
         // Scale limits based on available memory
         // 1GB = 10K limit, 8GB = 80K limit, etc.
         this.maxLimit = Math.min(100000, // Absolute max for safety
@@ -179,8 +203,8 @@ export function getValidationConfig() {
         maxLimit: config.maxLimit,
         maxQueryLength: config.maxQueryLength,
         maxVectorDimensions: config.maxVectorDimensions,
-        systemMemory: os.totalmem(),
-        availableMemory: os.freemem()
+        systemMemory: getSystemMemory(),
+        availableMemory: getAvailableMemory()
     };
 }
 /**

package/dist/utils/structuredLogger.js

@@ -4,8 +4,7 @@
  * performance tracking, and multiple transport support
  */
 import { performance } from 'perf_hooks';
-import { hostname } from 'node:os';
-import { randomUUID } from 'node:crypto';
+import { randomUUID } from '../universal/crypto.js';
 export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["SILENT"] = -1] = "SILENT";
@@ -214,9 +213,21 @@ export class StructuredLogger {
             };
         }
         if (this.config.includeHost) {
-            entry.host = hostname();
+            // Use dynamic import for hostname (Node.js only)
+            if (typeof window === 'undefined') {
+                try {
+                    const os = require('node:os');
+                    entry.host = os.hostname();
+                }
+                catch {
+                    entry.host = 'unknown';
+                }
+            }
+            else {
+                entry.host = window.location?.hostname || 'browser';
+            }
         }
-        if (this.config.includeMemory) {
+        if (this.config.includeMemory && typeof process !== 'undefined' && process.memoryUsage) {
             const mem = process.memoryUsage();
             entry.performance = {
                 memory: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.6.0",
+  "version": "3.7.1",
   "description": "Universal Knowledge Protocol™ - World's first Triple Intelligence database unifying vector, graph, and document search in one API. 31 nouns × 40 verbs for infinite expressiveness.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -41,6 +41,11 @@
       "types": "./dist/universal/index.d.ts"
     }
   },
+  "browser": {
+    "./dist/distributed": false,
+    "./dist/cli": false,
+    "./dist/scripts": false
+  },
   "engines": {
     "node": "22.x"
   },