@soulcraft/brainy 2.15.0 → 3.0.1

package/dist/utils/embedding.js

@@ -251,21 +251,17 @@ export class TransformerEmbedding {
             let actualType = embeddingManager.getPrecision();
             // CRITICAL: Control which model precision transformers.js uses
             // Q8 models use quantized int8 weights for 75% size reduction
-            // FP32 models use full precision floating point
-            if (actualType === 'q8') {
-                this.logger('log', '🎯 Selecting Q8 quantized model (75% smaller, 99% accuracy)');
-            }
-            else {
-                this.logger('log', '📦 Using FP32 model (full precision, larger size)');
-            }
+            // Always use Q8 for optimal balance
+            actualType = 'q8'; // Always Q8
+            this.logger('log', '🎯 Using Q8 quantized model (75% smaller, 99% accuracy)');
             // Load the feature extraction pipeline with memory optimizations
             const pipelineOptions = {
                 cache_dir: cacheDir,
                 local_files_only: isBrowser() ? false : this.options.localFilesOnly,
                 // CRITICAL: Specify dtype for model precision
-                dtype: actualType === 'q8' ? 'q8' : 'fp32',
+                dtype: 'q8',
                 // CRITICAL: For Q8, explicitly use quantized model
-                quantized: actualType === 'q8',
+                quantized: true,
                 // CRITICAL: ONNX memory optimizations
                 session_options: {
                     enableCpuMemArena: false, // Disable pre-allocated memory arena
@@ -292,8 +288,8 @@ export class TransformerEmbedding {
                         this.logger('log', '✅ Q8 model found locally');
                     }
                     else {
-                        this.logger('warn', '⚠️ Q8 model not found, will fall back to FP32');
-                        actualType = 'fp32'; // Fall back to fp32
+                        this.logger('warn', '⚠️ Q8 model not found');
+                        actualType = 'q8'; // Always Q8
                     }
                 }
                 this.extractor = await pipeline('feature-extraction', this.options.model, pipelineOptions);
@@ -462,9 +458,7 @@ export function createEmbeddingFunction(options = {}) {
     return async (data) => {
         const { embeddingManager } = await import('../embeddings/EmbeddingManager.js');
         // Validate precision if specified
-        if (options.precision) {
-            embeddingManager.validatePrecision(options.precision);
-        }
+        // Precision is always Q8 now
         return await embeddingManager.embed(data);
     };
 }

package/dist/utils/enhancedLogger.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Enhanced logging system that bridges old logger with new structured logger
+ * Provides backward compatibility while enabling gradual migration
+ */
+import { type LogContext } from './structuredLogger.js';
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3,
+    TRACE = 4
+}
+export interface LoggerConfig {
+    level: LogLevel;
+    modules?: {
+        [moduleName: string]: LogLevel;
+    };
+    timestamps?: boolean;
+    includeModule?: boolean;
+    handler?: (level: LogLevel, module: string, message: string, ...args: any[]) => void;
+}
+/**
+ * Enhanced Logger that uses structured logger internally
+ * Maintains backward compatibility with existing code
+ */
+declare class EnhancedLogger {
+    private static instance;
+    private config;
+    private constructor();
+    private applyEnvironmentDefaults;
+    private syncWithStructuredLogger;
+    static getInstance(): EnhancedLogger;
+    configure(config: Partial<LoggerConfig>): void;
+    private shouldLog;
+    error(module: string, message: string, ...args: any[]): void;
+    warn(module: string, message: string, ...args: any[]): void;
+    info(module: string, message: string, ...args: any[]): void;
+    debug(module: string, message: string, ...args: any[]): void;
+    trace(module: string, message: string, ...args: any[]): void;
+    createModuleLogger(module: string): {
+        error: (message: string, ...args: any[]) => void;
+        warn: (message: string, ...args: any[]) => void;
+        info: (message: string, ...args: any[]) => void;
+        debug: (message: string, ...args: any[]) => void;
+        trace: (message: string, ...args: any[]) => void;
+        withContext: (context: LogContext) => {
+            fatal: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+            error: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+            warn: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+            info: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+            debug: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+            trace: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+            withContext: (context: LogContext) => /*elided*/ any;
+            startTimer: (label: string) => void;
+            endTimer: (label: string) => number | undefined;
+        };
+        startTimer: (label: string) => void;
+        endTimer: (label: string) => number | undefined;
+    };
+}
+export declare const logger: EnhancedLogger;
+export declare function createModuleLogger(module: string): {
+    error: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    trace: (message: string, ...args: any[]) => void;
+    withContext: (context: LogContext) => {
+        fatal: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+        error: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+        warn: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+        info: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+        debug: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+        trace: (message: string, contextOrData?: LogContext | any, data?: any) => void;
+        withContext: (context: LogContext) => /*elided*/ any;
+        startTimer: (label: string) => void;
+        endTimer: (label: string) => number | undefined;
+    };
+    startTimer: (label: string) => void;
+    endTimer: (label: string) => number | undefined;
+};
+export declare function configureLogger(config: Partial<LoggerConfig>): void;
+/**
+ * Smart console replacement that uses structured logger
+ */
+export declare const smartConsole: {
+    log: (message?: any, ...args: any[]) => void;
+    info: (message?: any, ...args: any[]) => void;
+    warn: (message?: any, ...args: any[]) => void;
+    error: (message?: any, ...args: any[]) => void;
+    debug: (message?: any, ...args: any[]) => void;
+    trace: (message?: any, ...args: any[]) => void;
+};
+/**
+ * Production-optimized logging functions
+ */
+export declare const prodLog: {
+    error: (message?: any, ...args: any[]) => void;
+    warn: (message?: any, ...args: any[]) => void;
+    info: (message?: any, ...args: any[]) => void;
+    debug: (message?: any, ...args: any[]) => void;
+    log: (message?: any, ...args: any[]) => void;
+};
+export { createModuleLogger as createStructuredModuleLogger, type LogContext, type ModuleLogger } from './structuredLogger.js';

package/dist/utils/enhancedLogger.js

@@ -0,0 +1,232 @@
+/**
+ * Enhanced logging system that bridges old logger with new structured logger
+ * Provides backward compatibility while enabling gradual migration
+ */
+import { structuredLogger, createModuleLogger as createStructuredModuleLogger, LogLevel as StructuredLogLevel } from './structuredLogger.js';
+import { isProductionEnvironment, getLogLevel } from './environment.js';
+// Re-export LogLevel for compatibility
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+// Map old LogLevel to new StructuredLogLevel
+function mapLogLevel(level) {
+    switch (level) {
+        case LogLevel.ERROR: return StructuredLogLevel.ERROR;
+        case LogLevel.WARN: return StructuredLogLevel.WARN;
+        case LogLevel.INFO: return StructuredLogLevel.INFO;
+        case LogLevel.DEBUG: return StructuredLogLevel.DEBUG;
+        case LogLevel.TRACE: return StructuredLogLevel.TRACE;
+        default: return StructuredLogLevel.INFO;
+    }
+}
+/**
+ * Enhanced Logger that uses structured logger internally
+ * Maintains backward compatibility with existing code
+ */
+class EnhancedLogger {
+    constructor() {
+        this.config = {
+            level: LogLevel.ERROR,
+            timestamps: false,
+            includeModule: true
+        };
+        this.applyEnvironmentDefaults();
+        // Sync with structured logger
+        this.syncWithStructuredLogger();
+        // Set log level from environment variable if available
+        const envLogLevel = process.env.BRAINY_LOG_LEVEL;
+        if (envLogLevel) {
+            const level = LogLevel[envLogLevel.toUpperCase()];
+            if (level !== undefined) {
+                this.config.level = level;
+                this.syncWithStructuredLogger();
+            }
+        }
+        // Parse module-specific log levels
+        const moduleLogLevels = process.env.BRAINY_MODULE_LOG_LEVELS;
+        if (moduleLogLevels) {
+            try {
+                this.config.modules = JSON.parse(moduleLogLevels);
+                this.syncWithStructuredLogger();
+            }
+            catch (e) {
+                // Ignore parsing errors
+            }
+        }
+    }
+    applyEnvironmentDefaults() {
+        const envLogLevel = getLogLevel();
+        switch (envLogLevel) {
+            case 'silent':
+                this.config.level = -1;
+                break;
+            case 'error':
+                this.config.level = LogLevel.ERROR;
+                this.config.timestamps = false;
+                break;
+            case 'warn':
+                this.config.level = LogLevel.WARN;
+                this.config.timestamps = false;
+                break;
+            case 'info':
+                this.config.level = LogLevel.INFO;
+                this.config.timestamps = true;
+                break;
+            case 'verbose':
+                this.config.level = LogLevel.DEBUG;
+                this.config.timestamps = true;
+                break;
+        }
+        if (isProductionEnvironment()) {
+            this.config.level = Math.min(this.config.level, LogLevel.ERROR);
+            this.config.timestamps = false;
+            this.config.includeModule = false;
+        }
+    }
+    syncWithStructuredLogger() {
+        // Convert modules config
+        const modules = {};
+        if (this.config.modules) {
+            for (const [module, level] of Object.entries(this.config.modules)) {
+                modules[module] = mapLogLevel(level);
+            }
+        }
+        // Configure structured logger
+        structuredLogger.configure({
+            level: mapLogLevel(this.config.level),
+            modules,
+            format: this.config.timestamps ? 'pretty' : 'simple'
+        });
+    }
+    static getInstance() {
+        if (!EnhancedLogger.instance) {
+            EnhancedLogger.instance = new EnhancedLogger();
+        }
+        return EnhancedLogger.instance;
+    }
+    configure(config) {
+        this.config = { ...this.config, ...config };
+        this.syncWithStructuredLogger();
+    }
+    shouldLog(level, module) {
+        if (this.config.modules && this.config.modules[module] !== undefined) {
+            return level <= this.config.modules[module];
+        }
+        return level <= this.config.level;
+    }
+    error(module, message, ...args) {
+        const logger = createStructuredModuleLogger(module);
+        logger.error(message, { data: args });
+    }
+    warn(module, message, ...args) {
+        const logger = createStructuredModuleLogger(module);
+        logger.warn(message, { data: args });
+    }
+    info(module, message, ...args) {
+        const logger = createStructuredModuleLogger(module);
+        logger.info(message, { data: args });
+    }
+    debug(module, message, ...args) {
+        const logger = createStructuredModuleLogger(module);
+        logger.debug(message, { data: args });
+    }
+    trace(module, message, ...args) {
+        const logger = createStructuredModuleLogger(module);
+        logger.trace(message, { data: args });
+    }
+    createModuleLogger(module) {
+        const structuredLogger = createStructuredModuleLogger(module);
+        // Return a backward-compatible interface
+        return {
+            error: (message, ...args) => structuredLogger.error(message, { data: args }),
+            warn: (message, ...args) => structuredLogger.warn(message, { data: args }),
+            info: (message, ...args) => structuredLogger.info(message, { data: args }),
+            debug: (message, ...args) => structuredLogger.debug(message, { data: args }),
+            trace: (message, ...args) => structuredLogger.trace(message, { data: args }),
+            // New structured logging methods
+            withContext: (context) => structuredLogger.withContext(context),
+            startTimer: (label) => structuredLogger.startTimer(label),
+            endTimer: (label) => structuredLogger.endTimer(label)
+        };
+    }
+}
+// Export singleton instance
+export const logger = EnhancedLogger.getInstance();
+// Export convenience function for creating module loggers
+export function createModuleLogger(module) {
+    return logger.createModuleLogger(module);
+}
+// Export function to configure logger
+export function configureLogger(config) {
+    logger.configure(config);
+}
+/**
+ * Smart console replacement that uses structured logger
+ */
+export const smartConsole = {
+    log: (message, ...args) => {
+        const logger = createStructuredModuleLogger('console');
+        logger.info(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    },
+    info: (message, ...args) => {
+        const logger = createStructuredModuleLogger('console');
+        logger.info(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    },
+    warn: (message, ...args) => {
+        const logger = createStructuredModuleLogger('console');
+        logger.warn(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    },
+    error: (message, ...args) => {
+        const logger = createStructuredModuleLogger('console');
+        logger.error(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    },
+    debug: (message, ...args) => {
+        const logger = createStructuredModuleLogger('console');
+        logger.debug(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    },
+    trace: (message, ...args) => {
+        const logger = createStructuredModuleLogger('console');
+        logger.trace(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    }
+};
+/**
+ * Production-optimized logging functions
+ */
+export const prodLog = {
+    error: (message, ...args) => {
+        const logger = createStructuredModuleLogger('prod');
+        logger.error(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+    },
+    warn: (message, ...args) => {
+        if (!isProductionEnvironment() || process.env.BRAINY_LOG_LEVEL) {
+            const logger = createStructuredModuleLogger('prod');
+            logger.warn(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+        }
+    },
+    info: (message, ...args) => {
+        if (!isProductionEnvironment() || process.env.BRAINY_LOG_LEVEL) {
+            const logger = createStructuredModuleLogger('prod');
+            logger.info(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+        }
+    },
+    debug: (message, ...args) => {
+        if (!isProductionEnvironment() || process.env.BRAINY_LOG_LEVEL) {
+            const logger = createStructuredModuleLogger('prod');
+            logger.debug(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+        }
+    },
+    log: (message, ...args) => {
+        if (!isProductionEnvironment() || process.env.BRAINY_LOG_LEVEL) {
+            const logger = createStructuredModuleLogger('prod');
+            logger.info(typeof message === 'string' ? message : JSON.stringify(message), { data: args });
+        }
+    }
+};
+// Re-export structured logger utilities for new code
+export { createModuleLogger as createStructuredModuleLogger } from './structuredLogger.js';
+//# sourceMappingURL=enhancedLogger.js.map

package/dist/utils/index.d.ts

@@ -1,7 +1,7 @@
 export * from './distance.js';
 export * from './embedding.js';
 export * from './workerUtils.js';
-export * from './statistics.js';
+export * from './statisticsCollector.js';
 export * from './jsonProcessing.js';
 export * from './fieldNameTracking.js';
 export * from './version.js';

package/dist/utils/index.js

@@ -1,7 +1,7 @@
 export * from './distance.js';
 export * from './embedding.js';
 export * from './workerUtils.js';
-export * from './statistics.js';
+export * from './statisticsCollector.js';
 export * from './jsonProcessing.js';
 export * from './fieldNameTracking.js';
 export * from './version.js';

package/dist/utils/intelligentTypeMapper.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Intelligent Type Mapper
+ * Maps generic/invalid type names to specific semantic types based on data analysis
+ * Prevents semantic degradation from overuse of generic types
+ */
+/**
+ * Intelligent Type Mapper
+ */
+export declare class IntelligentTypeMapper {
+    private typeCache;
+    private inferenceStats;
+    /**
+     * Map a noun type, with intelligent inference for generic types
+     */
+    mapNounType(inputType: string, data?: any): string;
+    /**
+     * Map a verb type
+     */
+    mapVerbType(inputType: string): string;
+    /**
+     * Infer type from data structure
+     */
+    private inferTypeFromData;
+    /**
+     * Get direct mapping for common aliases
+     */
+    private getDirectMapping;
+    /**
+     * Check if a type is valid
+     */
+    private isValidNounType;
+    /**
+     * Check if a verb type is valid
+     */
+    private isValidVerbType;
+    /**
+     * Get inference statistics
+     */
+    getStats(): {
+        cacheSize: number;
+        inferenceRate: number;
+        total: number;
+        inferred: number;
+        defaulted: number;
+        cached: number;
+    };
+    /**
+     * Clear the type cache
+     */
+    clearCache(): void;
+}
+export declare const typeMapper: IntelligentTypeMapper;
+/**
+ * Helper function for easy type mapping
+ */
+export declare function mapNounType(inputType: string, data?: any): string;
+/**
+ * Helper function for verb mapping
+ */
+export declare function mapVerbType(inputType: string): string;