@soulcraft/brainy 0.63.0 → 1.0.0-rc.2

package/dist/sequentialPipeline.js

@@ -1,417 +0,0 @@
-/**
- * Sequential Augmentation Pipeline
- *
- * This module provides a pipeline for executing augmentations in a specific sequence:
- * ISense -> IMemory -> ICognition -> IConduit -> IActivation -> IPerception
- *
- * It supports high-performance streaming data from WebSockets without blocking.
- * Optimized for Node.js 23.11+ using native WebStreams API.
- */
-import { AugmentationType } from './types/augmentations.js';
-import { BrainyData } from './brainyData.js';
-import { augmentationPipeline } from './augmentationPipeline.js';
-// Use the browser's built-in WebStreams API or Node.js native WebStreams API
-// This approach ensures compatibility with both environments
-let TransformStream, ReadableStream, WritableStream;
-// Function to initialize the stream classes
-const initializeStreamClasses = () => {
-    // Try to use the browser's built-in WebStreams API first
-    if (typeof globalThis.TransformStream !== 'undefined' &&
-        typeof globalThis.ReadableStream !== 'undefined' &&
-        typeof globalThis.WritableStream !== 'undefined') {
-        TransformStream = globalThis.TransformStream;
-        ReadableStream = globalThis.ReadableStream;
-        WritableStream = globalThis.WritableStream;
-        return Promise.resolve();
-    }
-    else {
-        // In Node.js environment, try to import from node:stream/web
-        // This will be executed in Node.js but not in browsers
-        return import('node:stream/web')
-            .then(streamWebModule => {
-            TransformStream = streamWebModule.TransformStream;
-            ReadableStream = streamWebModule.ReadableStream;
-            WritableStream = streamWebModule.WritableStream;
-        })
-            .catch(error => {
-            console.error('Failed to import WebStreams API:', error);
-            // Provide fallback implementations or throw a more helpful error
-            throw new Error('WebStreams API is not available in this environment. Please use a modern browser or Node.js 18+.');
-        });
-    }
-};
-// Initialize immediately but don't block module execution
-const streamClassesPromise = initializeStreamClasses();
-/**
- * Default pipeline options
- */
-const DEFAULT_SEQUENTIAL_PIPELINE_OPTIONS = {
-    timeout: 30000,
-    stopOnError: false
-};
-/**
- * SequentialPipeline class
- *
- * Executes augmentations in a specific sequence:
- * ISense -> IMemory -> ICognition -> IConduit -> IActivation -> IPerception
- */
-export class SequentialPipeline {
-    /**
-     * Create a new sequential pipeline
-     *
-     * @param options Options for the pipeline
-     */
-    constructor(options = {}) {
-        this.brainyData = options.brainyData || new BrainyData();
-    }
-    /**
-     * Ensure stream classes are initialized
-     * @private
-     */
-    async ensureStreamClassesInitialized() {
-        await streamClassesPromise;
-    }
-    /**
-     * Initialize the pipeline
-     *
-     * @returns A promise that resolves when initialization is complete
-     */
-    async initialize() {
-        // Initialize stream classes and BrainyData in parallel
-        await Promise.all([
-            this.ensureStreamClassesInitialized(),
-            this.brainyData.init()
-        ]);
-    }
-    /**
-     * Process data through the sequential pipeline
-     *
-     * @param rawData The raw data to process
-     * @param dataType The type of data (e.g., 'text', 'image', 'audio')
-     * @param options Options for pipeline execution
-     * @returns A promise that resolves with the pipeline result
-     */
-    async processData(rawData, dataType, options = {}) {
-        const opts = { ...DEFAULT_SEQUENTIAL_PIPELINE_OPTIONS, ...options };
-        const result = {
-            success: true,
-            data: null,
-            stageResults: {}
-        };
-        try {
-            // Step 1: Process raw data with ISense augmentations
-            const senseResults = await augmentationPipeline.executeSensePipeline('processRawData', [rawData, dataType], { timeout: opts.timeout, stopOnError: opts.stopOnError });
-            // Get the first successful result
-            let senseResult = null;
-            for (const resultPromise of senseResults) {
-                const res = await resultPromise;
-                if (res.success) {
-                    senseResult = res;
-                    break;
-                }
-            }
-            if (!senseResult || !senseResult.success) {
-                return {
-                    success: false,
-                    data: null,
-                    error: 'Failed to process raw data with ISense augmentations',
-                    stageResults: { sense: senseResult || { success: false, data: null, error: 'No sense augmentations available' } }
-                };
-            }
-            result.stageResults.sense = senseResult;
-            // Step 2: Store data in BrainyData using IMemory augmentations
-            const memoryAugmentations = augmentationPipeline.getAugmentationsByType(AugmentationType.MEMORY);
-            if (memoryAugmentations.length === 0) {
-                return {
-                    success: false,
-                    data: null,
-                    error: 'No memory augmentations available',
-                    stageResults: result.stageResults
-                };
-            }
-            // Use the first available memory augmentation
-            const memoryAugmentation = memoryAugmentations[0];
-            // Generate a key for the data
-            const dataKey = `data_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
-            // Store the data
-            const memoryResult = await memoryAugmentation.storeData(dataKey, {
-                rawData,
-                dataType,
-                nouns: senseResult.data.nouns,
-                verbs: senseResult.data.verbs,
-                timestamp: Date.now()
-            });
-            if (!memoryResult.success) {
-                return {
-                    success: false,
-                    data: null,
-                    error: `Failed to store data: ${memoryResult.error}`,
-                    stageResults: { ...result.stageResults, memory: memoryResult }
-                };
-            }
-            result.stageResults.memory = memoryResult;
-            // Step 3: Trigger ICognition augmentations to analyze the data
-            const cognitionResults = await augmentationPipeline.executeCognitionPipeline('reason', [`Analyze data with key ${dataKey}`, { dataKey }], { timeout: opts.timeout, stopOnError: opts.stopOnError });
-            // Get the first successful result
-            let cognitionResult = null;
-            for (const resultPromise of cognitionResults) {
-                const res = await resultPromise;
-                if (res.success) {
-                    cognitionResult = res;
-                    break;
-                }
-            }
-            if (cognitionResult) {
-                result.stageResults.cognition = cognitionResult;
-            }
-            // Step 4: Send notifications to IConduit augmentations
-            const conduitResults = await augmentationPipeline.executeConduitPipeline('writeData', [{ dataKey, nouns: senseResult.data.nouns, verbs: senseResult.data.verbs }], { timeout: opts.timeout, stopOnError: opts.stopOnError });
-            // Get the first successful result
-            let conduitResult = null;
-            for (const resultPromise of conduitResults) {
-                const res = await resultPromise;
-                if (res.success) {
-                    conduitResult = res;
-                    break;
-                }
-            }
-            if (conduitResult) {
-                result.stageResults.conduit = conduitResult;
-            }
-            // Step 5: Send notifications to IActivation augmentations
-            const activationResults = await augmentationPipeline.executeActivationPipeline('triggerAction', ['dataProcessed', { dataKey }], { timeout: opts.timeout, stopOnError: opts.stopOnError });
-            // Get the first successful result
-            let activationResult = null;
-            for (const resultPromise of activationResults) {
-                const res = await resultPromise;
-                if (res.success) {
-                    activationResult = res;
-                    break;
-                }
-            }
-            if (activationResult) {
-                result.stageResults.activation = activationResult;
-            }
-            // Step 6: Send notifications to IPerception augmentations
-            const perceptionResults = await augmentationPipeline.executePerceptionPipeline('interpret', [senseResult.data.nouns, senseResult.data.verbs, { dataKey }], { timeout: opts.timeout, stopOnError: opts.stopOnError });
-            // Get the first successful result
-            let perceptionResult = null;
-            for (const resultPromise of perceptionResults) {
-                const res = await resultPromise;
-                if (res.success) {
-                    perceptionResult = res;
-                    break;
-                }
-            }
-            if (perceptionResult) {
-                result.stageResults.perception = perceptionResult;
-                result.data = perceptionResult.data;
-            }
-            else {
-                // If no perception result, use the cognition result as the final data
-                result.data = cognitionResult ? cognitionResult.data : { dataKey };
-            }
-            return result;
-        }
-        catch (error) {
-            return {
-                success: false,
-                data: null,
-                error: `Pipeline execution failed: ${error}`,
-                stageResults: result.stageResults
-            };
-        }
-    }
-    /**
-     * Process WebSocket data through the sequential pipeline
-     *
-     * @param connection The WebSocket connection
-     * @param dataType The type of data (e.g., 'text', 'image', 'audio')
-     * @param options Options for pipeline execution
-     * @returns A function to handle incoming WebSocket messages
-     */
-    async createWebSocketHandler(connection, dataType, options = {}) {
-        // Ensure stream classes are initialized
-        await this.ensureStreamClassesInitialized();
-        // Create a transform stream for processing data
-        const transformStream = new TransformStream({
-            transform: async (chunk, controller) => {
-                try {
-                    const data = typeof chunk === 'string' ? chunk : JSON.stringify(chunk);
-                    const result = await this.processData(data, dataType, options);
-                    if (result.success) {
-                        controller.enqueue(result);
-                    }
-                    else {
-                        console.warn('Pipeline processing failed:', result.error);
-                    }
-                }
-                catch (error) {
-                    console.error('Error in transform stream:', error);
-                }
-            }
-        });
-        // Create a writable stream that will be the sink for our data
-        const writableStream = new WritableStream({
-            write: async (result) => {
-                // Handle the processed result if needed
-                if (connection.send && typeof connection.send === 'function') {
-                    try {
-                        // Only send back results if the connection supports it
-                        await connection.send(JSON.stringify(result));
-                    }
-                    catch (error) {
-                        console.error('Error sending result back to WebSocket:', error);
-                    }
-                }
-            }
-        });
-        // Connect the transform stream to the writable stream
-        transformStream.readable.pipeTo(writableStream).catch((error) => {
-            console.error('Error in pipeline stream:', error);
-        });
-        // Return a function that writes to the transform stream
-        return (data) => {
-            try {
-                // Write to the transform stream's writable side
-                const writer = transformStream.writable.getWriter();
-                writer.write(data).catch((error) => {
-                    console.error('Error writing to stream:', error);
-                }).finally(() => {
-                    writer.releaseLock();
-                });
-            }
-            catch (error) {
-                console.error('Error getting writer for transform stream:', error);
-            }
-        };
-    }
-    /**
-     * Set up a WebSocket connection to process data through the pipeline
-     *
-     * @param url The WebSocket URL to connect to
-     * @param dataType The type of data (e.g., 'text', 'image', 'audio')
-     * @param options Options for pipeline execution
-     * @returns A promise that resolves with the WebSocket connection and associated streams
-     */
-    async setupWebSocketPipeline(url, dataType, options = {}) {
-        // Ensure stream classes are initialized
-        await this.ensureStreamClassesInitialized();
-        // Get WebSocket-supporting augmentations
-        const webSocketAugmentations = augmentationPipeline.getWebSocketAugmentations();
-        if (webSocketAugmentations.length === 0) {
-            throw new Error('No WebSocket-supporting augmentations available');
-        }
-        // Use the first available WebSocket augmentation
-        const webSocketAugmentation = webSocketAugmentations[0];
-        // Connect to the WebSocket
-        const connection = await webSocketAugmentation.connectWebSocket(url);
-        // Create a readable stream from the WebSocket messages
-        const readableStream = new ReadableStream({
-            start: (controller) => {
-                // Define a message handler that writes to the stream
-                const messageHandler = (event) => {
-                    try {
-                        const data = typeof event.data === 'string'
-                            ? event.data
-                            : event.data instanceof Blob
-                                ? new Promise(resolve => {
-                                    const reader = new FileReader();
-                                    reader.onload = () => resolve(reader.result);
-                                    reader.readAsText(event.data);
-                                })
-                                : JSON.stringify(event.data);
-                        // Handle both string data and promises
-                        if (data instanceof Promise) {
-                            data.then(resolvedData => {
-                                controller.enqueue(resolvedData);
-                            }).catch((error) => {
-                                console.error('Error processing blob data:', error);
-                            });
-                        }
-                        else {
-                            controller.enqueue(data);
-                        }
-                    }
-                    catch (error) {
-                        console.error('Error processing WebSocket message:', error);
-                    }
-                };
-                // Create a wrapper function that adapts the event-based handler to the data-based callback
-                const messageHandlerWrapper = (data) => {
-                    messageHandler({ data });
-                };
-                // Store both handlers for later cleanup
-                connection._streamMessageHandler = messageHandler;
-                connection._messageHandlerWrapper = messageHandlerWrapper;
-                webSocketAugmentation.onWebSocketMessage(connection.connectionId, messageHandlerWrapper).catch((error) => {
-                    console.error('Error registering WebSocket message handler:', error);
-                    controller.error(error);
-                });
-            },
-            cancel: () => {
-                // Clean up the message handler when the stream is cancelled
-                if (connection._messageHandlerWrapper) {
-                    webSocketAugmentation.offWebSocketMessage(connection.connectionId, connection._messageHandlerWrapper).catch((error) => {
-                        console.error('Error removing WebSocket message handler:', error);
-                    });
-                    delete connection._streamMessageHandler;
-                    delete connection._messageHandlerWrapper;
-                }
-            }
-        });
-        // Create a handler for processing the data
-        const handlerPromise = this.createWebSocketHandler(connection, dataType, options);
-        // Create a writable stream that sends data to the WebSocket
-        const writableStream = new WritableStream({
-            write: async (chunk) => {
-                if (connection.send && typeof connection.send === 'function') {
-                    try {
-                        const data = typeof chunk === 'string' ? chunk : JSON.stringify(chunk);
-                        await connection.send(data);
-                    }
-                    catch (error) {
-                        console.error('Error sending data to WebSocket:', error);
-                        throw error;
-                    }
-                }
-                else {
-                    throw new Error('WebSocket connection does not support sending data');
-                }
-            },
-            close: () => {
-                // Close the WebSocket connection when the stream is closed
-                if (connection.close && typeof connection.close === 'function') {
-                    connection.close().catch((error) => {
-                        console.error('Error closing WebSocket connection:', error);
-                    });
-                }
-            }
-        });
-        // Pipe the readable stream through our processing pipeline
-        readableStream
-            .pipeThrough(new TransformStream({
-            transform: async (chunk, controller) => {
-                // Process each chunk through our handler
-                const handler = await handlerPromise;
-                handler(chunk);
-                // Pass through the original data
-                controller.enqueue(chunk);
-            }
-        }))
-            .pipeTo(new WritableStream({
-            write: () => { },
-            abort: (error) => {
-                console.error('Error in WebSocket pipeline:', error);
-            }
-        }));
-        // Attach the streams to the connection object for convenience
-        const enhancedConnection = connection;
-        enhancedConnection.readableStream = readableStream;
-        enhancedConnection.writableStream = writableStream;
-        return enhancedConnection;
-    }
-}
-// Create and export a default instance of the sequential pipeline
-export const sequentialPipeline = new SequentialPipeline();
-//# sourceMappingURL=sequentialPipeline.js.map

package/dist/utils/modelLoader.d.ts

@@ -1,12 +0,0 @@
-/**
- * Smart Model Loader - Zero Configuration ML Models
- * Downloads models on-demand, caches intelligently
- */
-export declare class SmartModelLoader {
-    private static readonly MODEL_SOURCES;
-    static loadModel(modelName: string): Promise<ArrayBuffer>;
-    private static tryLoadFrom;
-    private static cacheLocally;
-    private static generateFallbackModel;
-}
-export declare function getEmbedding(text: string): Promise<Float32Array>;

package/dist/utils/modelLoader.js

@@ -1,88 +0,0 @@
-/**
- * Smart Model Loader - Zero Configuration ML Models
- * Downloads models on-demand, caches intelligently
- */
-export class SmartModelLoader {
-    static async loadModel(modelName) {
-        // Try each source in order
-        for (const source of this.MODEL_SOURCES) {
-            try {
-                const model = await this.tryLoadFrom(source, modelName);
-                if (model) {
-                    await this.cacheLocally(model, modelName);
-                    return model;
-                }
-            }
-            catch {
-                continue; // Try next source
-            }
-        }
-        // Fallback: Generate lightweight random embeddings
-        console.warn('Using fallback embeddings (reduced accuracy)');
-        return this.generateFallbackModel(modelName);
-    }
-    static async tryLoadFrom(source, model) {
-        if (source.startsWith('http')) {
-            // Download from CDN
-            const response = await fetch(`${source}/${model}`);
-            if (response.ok) {
-                return await response.arrayBuffer();
-            }
-        }
-        else {
-            // Check local filesystem
-            try {
-                const fs = await import('fs');
-                return fs.readFileSync(`${source}/${model}`);
-            }
-            catch {
-                return null;
-            }
-        }
-        return null;
-    }
-    static async cacheLocally(model, name) {
-        // Cache in best available location
-        if (typeof window !== 'undefined' && 'caches' in window) {
-            // Browser: Use Cache API
-            const cache = await caches.open('brainy-models');
-            await cache.put(name, new Response(model));
-        }
-        else if (typeof process !== 'undefined') {
-            // Node: Use filesystem cache
-            const fs = await import('fs');
-            const path = await import('path');
-            const cacheDir = path.join(process.env.HOME || '', '.brainy', 'models');
-            fs.mkdirSync(cacheDir, { recursive: true });
-            fs.writeFileSync(path.join(cacheDir, name), Buffer.from(model));
-        }
-    }
-    static generateFallbackModel(name) {
-        // Deterministic "random" embeddings based on input
-        // Good enough for development/testing
-        const seed = name.split('').reduce((a, b) => a + b.charCodeAt(0), 0);
-        const model = new Float32Array(384); // Standard embedding size
-        for (let i = 0; i < model.length; i++) {
-            model[i] = Math.sin(seed * (i + 1)) * 0.1;
-        }
-        return model.buffer;
-    }
-}
-SmartModelLoader.MODEL_SOURCES = [
-    // 1. Check if bundled locally
-    './models',
-    '../models',
-    // 2. Check user's cache
-    '~/.brainy/models',
-    // 3. Check CDN (fast, free)
-    'https://cdn.jsdelivr.net/npm/@brainy/models@latest',
-    'https://unpkg.com/@brainy/models',
-    // 4. Check Hugging Face (original source)
-    'https://huggingface.co/Xenova/all-MiniLM-L6-v2/resolve/main'
-];
-// Usage - Zero configuration required!
-export async function getEmbedding(text) {
-    const model = await SmartModelLoader.loadModel('encoder.onnx');
-    // ... use model
-}
-//# sourceMappingURL=modelLoader.js.map