@soulcraft/brainy 3.5.1 → 3.7.0

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/configResolver.js

@@ -7,9 +7,7 @@
  * - Runtime updates
  * - Default values from schema
  */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { isNode } from '../utils/environment.js';
 /**
  * Configuration source priority (highest to lowest)
  */
@@ -29,14 +27,28 @@ export class AugmentationConfigResolver {
         this.options = options;
         this.sources = [];
         this.resolved = {};
+        // Default config paths - include home directory paths only in Node.js
+        const defaultConfigPaths = [
+            '.brainyrc',
+            '.brainyrc.json',
+            'brainy.config.json'
+        ];
+        // Add home directory paths in Node.js environments
+        if (isNode()) {
+            try {
+                const nodeRequire = typeof require !== 'undefined' ? require : null;
+                if (nodeRequire) {
+                    const path = nodeRequire('node:path');
+                    const os = nodeRequire('node:os');
+                    defaultConfigPaths.push(path.join(os.homedir(), '.brainy', 'config.json'), path.join(os.homedir(), '.brainyrc'));
+                }
+            }
+            catch {
+                // Silently continue without home directory paths
+            }
+        }
         this.options = {
-            configPaths: [
-                '.brainyrc',
-                '.brainyrc.json',
-                'brainy.config.json',
-                join(homedir(), '.brainy', 'config.json'),
-                join(homedir(), '.brainyrc')
-            ],
+            configPaths: defaultConfigPaths,
             envPrefix: `BRAINY_AUG_${options.augmentationId.toUpperCase()}_`,
             allowUndefined: true,
             ...options
@@ -98,30 +110,39 @@ export class AugmentationConfigResolver {
      */
     loadFromFiles() {
         // Skip in browser environment
-        if (typeof process === 'undefined' || typeof window !== 'undefined') {
+        if (!isNode()) {
             return;
         }
-        for (const configPath of this.options.configPaths || []) {
-            try {
-                if (existsSync(configPath)) {
-                    const content = readFileSync(configPath, 'utf8');
-                    const config = this.parseConfigFile(content, configPath);
-                    // Extract augmentation-specific configuration
-                    const augConfig = this.extractAugmentationConfig(config);
-                    if (augConfig && Object.keys(augConfig).length > 0) {
-                        this.sources.push({
-                            priority: ConfigPriority.FILE,
-                            source: `file:${configPath}`,
-                            config: augConfig
-                        });
-                        break; // Use first found config file
+        try {
+            const nodeRequire = typeof require !== 'undefined' ? require : null;
+            if (!nodeRequire)
+                return;
+            const fs = nodeRequire('node:fs');
+            for (const configPath of this.options.configPaths || []) {
+                try {
+                    if (fs.existsSync(configPath)) {
+                        const content = fs.readFileSync(configPath, 'utf8');
+                        const config = this.parseConfigFile(content, configPath);
+                        // Extract augmentation-specific configuration
+                        const augConfig = this.extractAugmentationConfig(config);
+                        if (augConfig && Object.keys(augConfig).length > 0) {
+                            this.sources.push({
+                                priority: ConfigPriority.FILE,
+                                source: `file:${configPath}`,
+                                config: augConfig
+                            });
+                            break; // Use first found config file
+                        }
                     }
                 }
+                catch (error) {
+                    // Silently ignore file errors
+                    console.debug(`Failed to load config from ${configPath}:`, error);
+                }
             }
-            catch (error) {
-                // Silently ignore file errors
-                console.debug(`Failed to load config from ${configPath}:`, error);
-            }
+        }
+        catch {
+            // Silently continue if require fails
         }
     }
     /**
@@ -162,7 +183,7 @@ export class AugmentationConfigResolver {
      */
     loadFromEnvironment() {
         // Skip in browser environment
-        if (typeof process === 'undefined' || !process.env) {
+        if (!isNode() || !process.env) {
             return;
         }
         const prefix = this.options.envPrefix;
@@ -376,7 +397,7 @@ export class AugmentationConfigResolver {
      */
     async saveToFile(filepath, format = 'json') {
         // Skip in browser environment
-        if (typeof process === 'undefined' || typeof window !== 'undefined') {
+        if (!isNode()) {
             throw new Error('Cannot save configuration files in browser environment');
         }
         const fs = await import('node:fs');

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/embeddings/EmbeddingManager.d.ts

@@ -63,8 +63,12 @@ export declare class EmbeddingManager {
     getEmbeddingFunction(): EmbeddingFunction;
     /**
      * Get models directory path
+     * Note: In browser environments, returns a simple default path
+     * In Node.js, checks multiple locations for the models directory
      */
     private getModelsPath;
+    private modelsPathCache;
+    private resolveModelsPathSync;
     /**
      * Get memory usage in MB
      */

package/dist/embeddings/EmbeddingManager.js

@@ -16,8 +16,7 @@
  * hybridModelManager, universalMemoryManager, and more.
  */
 import { pipeline, env } from '@huggingface/transformers';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { isNode } from '../utils/environment.js';
 // Global state for true singleton across entire process
 let globalInstance = null;
 let globalInitPromise = null;
@@ -32,6 +31,7 @@ export class EmbeddingManager {
         this.initTime = null;
         this.embedCount = 0;
         this.locked = false;
+        this.modelsPathCache = null;
         // Always use Q8 for optimal size/performance (99% accuracy, 75% smaller)
         this.precision = 'q8';
         console.log(`🎯 EmbeddingManager: Using Q8 precision`);
@@ -95,11 +95,23 @@ export class EmbeddingManager {
             env.cacheDir = modelsPath;
             env.allowLocalModels = true;
             env.useFSCache = true;
-            // Check if models exist locally
-            const modelPath = join(modelsPath, ...this.modelName.split('/'));
-            const hasLocalModels = existsSync(modelPath);
-            if (hasLocalModels) {
-                console.log('✅ Using cached models from:', modelPath);
+            // Check if models exist locally (only in Node.js)
+            if (isNode()) {
+                try {
+                    const nodeRequire = typeof require !== 'undefined' ? require : null;
+                    if (nodeRequire) {
+                        const path = nodeRequire('node:path');
+                        const fs = nodeRequire('node:fs');
+                        const modelPath = path.join(modelsPath, ...this.modelName.split('/'));
+                        const hasLocalModels = fs.existsSync(modelPath);
+                        if (hasLocalModels) {
+                            console.log('✅ Using cached models from:', modelPath);
+                        }
+                    }
+                }
+                catch {
+                    // Silently continue if require fails
+                }
             }
             // Configure pipeline options for the selected precision
             const pipelineOptions = {
@@ -206,22 +218,52 @@ export class EmbeddingManager {
     }
     /**
      * Get models directory path
+     * Note: In browser environments, returns a simple default path
+     * In Node.js, checks multiple locations for the models directory
      */
     getModelsPath() {
-        // Check various possible locations
-        const paths = [
-            process.env.BRAINY_MODELS_PATH,
-            './models',
-            join(process.cwd(), 'models'),
-            join(process.env.HOME || '', '.brainy', 'models')
-        ];
-        for (const path of paths) {
-            if (path && existsSync(path)) {
-                return path;
+        // In browser environments, use a default path
+        if (!isNode()) {
+            return './models';
+        }
+        // Node.js-specific model path resolution
+        // Cache the result for performance
+        if (!this.modelsPathCache) {
+            this.modelsPathCache = this.resolveModelsPathSync();
+        }
+        return this.modelsPathCache;
+    }
+    resolveModelsPathSync() {
+        // For Node.js environments, we can safely assume these modules exist
+        // TypeScript will handle the imports at build time
+        // At runtime, these will only be called if isNode() is true
+        // Default fallback path
+        const defaultPath = './models';
+        try {
+            // Create a conditional require function that only works in Node
+            const nodeRequire = typeof require !== 'undefined' ? require : null;
+            if (!nodeRequire)
+                return defaultPath;
+            const fs = nodeRequire('node:fs');
+            const path = nodeRequire('node:path');
+            const paths = [
+                process.env.BRAINY_MODELS_PATH,
+                './models',
+                path.join(process.cwd(), 'models'),
+                path.join(process.env.HOME || '', '.brainy', 'models')
+            ];
+            for (const p of paths) {
+                if (p && fs.existsSync(p)) {
+                    return p;
+                }
             }
+            // Default Node.js path
+            return path.join(process.cwd(), 'models');
+        }
+        catch {
+            // Fallback if require fails
+            return defaultPath;
         }
-        // Default
-        return join(process.cwd(), 'models');
     }
     /**
      * Get memory usage in MB

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/dist/utils/version.d.ts

@@ -3,9 +3,17 @@
  */
 /**
  * Get the current Brainy package version
+ * In Node.js, attempts to read from package.json
+ * In browser, returns the default version
  * @returns The current version string
  */
 export declare function getBrainyVersion(): string;
+/**
+ * Get the current Brainy package version asynchronously
+ * Guaranteed to attempt loading from package.json in Node.js
+ * @returns Promise resolving to the current version string
+ */
+export declare function getBrainyVersionAsync(): Promise<string>;
 /**
  * Get version information for augmentation metadata
  * @param service The service/augmentation name

package/dist/utils/version.js

@@ -1,30 +1,77 @@
 /**
  * Version utilities for Brainy
  */
-import { readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-// Get package.json path relative to this file
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJsonPath = join(__dirname, '../../package.json');
+import { isNode } from './environment.js';
+// Default version - this should be replaced at build time
+const DEFAULT_VERSION = '3.5.1';
 let cachedVersion = null;
+let versionPromise = null;
+/**
+ * Load version from package.json in Node.js environment
+ */
+async function loadVersionFromPackageJson() {
+    if (!isNode()) {
+        return DEFAULT_VERSION;
+    }
+    try {
+        // Dynamic imports for Node.js modules - modern approach
+        const [{ readFileSync }, { join, dirname }, { fileURLToPath }] = await Promise.all([
+            import('node:fs'),
+            import('node:path'),
+            import('node:url')
+        ]);
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const packageJsonPath = join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.version || DEFAULT_VERSION;
+    }
+    catch (error) {
+        // Silently fall back to default version
+        return DEFAULT_VERSION;
+    }
+}
 /**
  * Get the current Brainy package version
+ * In Node.js, attempts to read from package.json
+ * In browser, returns the default version
  * @returns The current version string
  */
 export function getBrainyVersion() {
-    if (!cachedVersion) {
-        try {
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-            cachedVersion = packageJson.version;
-        }
-        catch {
-            // Fallback version if package.json can't be read
-            cachedVersion = '2.7.1';
-        }
-    }
-    return cachedVersion;
+    if (cachedVersion) {
+        return cachedVersion;
+    }
+    // In browser or if we need immediate response, return default
+    if (!isNode()) {
+        cachedVersion = DEFAULT_VERSION;
+        return cachedVersion;
+    }
+    // For Node.js, try to load synchronously first time
+    // This is a compromise for backward compatibility
+    if (!versionPromise) {
+        versionPromise = loadVersionFromPackageJson();
+        versionPromise.then(version => {
+            cachedVersion = version;
+        });
+    }
+    // Return default while loading
+    return cachedVersion || DEFAULT_VERSION;
+}
+/**
+ * Get the current Brainy package version asynchronously
+ * Guaranteed to attempt loading from package.json in Node.js
+ * @returns Promise resolving to the current version string
+ */
+export async function getBrainyVersionAsync() {
+    if (cachedVersion) {
+        return cachedVersion;
+    }
+    if (!versionPromise) {
+        versionPromise = loadVersionFromPackageJson();
+    }
+    const version = await versionPromise;
+    cachedVersion = version;
+    return version;
 }
 /**
  * Get version information for augmentation metadata

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soulcraft/brainy",
-  "version": "3.5.1",
+  "version": "3.7.0",
   "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"
   },