@soulcraft/brainy 3.5.0 → 3.6.0

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/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/universal/fs.js

@@ -9,7 +9,9 @@ let nodeFs = null;
 if (isNode()) {
     try {
         // Use node: protocol to prevent bundler polyfilling (requires Node 22+)
-        nodeFs = await import('node:fs/promises');
+        // Import main module and access promises to avoid subpath issues with bundlers
+        const fs = await import('node:fs');
+        nodeFs = fs.promises;
     }
     catch {
         // Ignore import errors in non-Node environments

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.0",
+  "version": "3.6.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",