@soulcraft/brainy 1.5.0 → 2.0.0

package/dist/augmentationPipeline.js

@@ -1,19 +1,13 @@
 /**
- * Cortex - The Brain's Orchestration System
+ * Augmentation Pipeline (Compatibility Layer)
  *
- * 🧠⚛️ The cerebral cortex that coordinates all augmentations
+ * @deprecated This file provides backward compatibility for code that imports
+ * from augmentationPipeline. All new code should use AugmentationRegistry directly.
  *
- * This module provides the central coordination system for managing and executing
- * augmentations across all categories. Like the brain's cortex, it orchestrates
- * different capabilities (augmentations) in sequence or parallel.
- *
- * @deprecated AugmentationPipeline - Use Cortex instead
+ * This minimal implementation redirects to the new AugmentationRegistry system.
  */
-import { AugmentationType } from './types/augmentations.js';
-import { isThreadingAvailable } from './utils/environment.js';
-import { executeInThread } from './utils/workerUtils.js';
 /**
- * Execution mode for the pipeline
+ * Execution mode for pipeline operations
  */
 export var ExecutionMode;
 (function (ExecutionMode) {
@@ -21,549 +15,105 @@ export var ExecutionMode;
     ExecutionMode["PARALLEL"] = "parallel";
     ExecutionMode["FIRST_SUCCESS"] = "firstSuccess";
     ExecutionMode["FIRST_RESULT"] = "firstResult";
-    ExecutionMode["THREADED"] = "threaded"; // Execute in separate threads when available
+    ExecutionMode["THREADED"] = "threaded";
 })(ExecutionMode || (ExecutionMode = {}));
 /**
- * Default pipeline options
- */
-const DEFAULT_PIPELINE_OPTIONS = {
-    mode: ExecutionMode.SEQUENTIAL,
-    timeout: 30000,
-    stopOnError: false,
-    forceThreading: false,
-    disableThreading: false
-};
-/**
- * Cortex class - The Brain's Orchestration Center
- *
- * Manages all augmentations like the cerebral cortex coordinates different brain regions.
- * This is the central pipeline that orchestrates all augmentation execution.
+ * Minimal Cortex class for backward compatibility
+ * Redirects all operations to the new AugmentationRegistry system
  */
 export class Cortex {
     constructor() {
-        this.registry = {
-            sense: [],
-            conduit: [],
-            cognition: [],
-            memory: [],
-            perception: [],
-            dialog: [],
-            activation: [],
-            webSocket: []
-        };
-    }
-    /**
-     * Register an augmentation with the cortex
-     *
-     * @param augmentation The augmentation to register
-     * @returns The cortex instance for chaining
-     */
-    register(augmentation) {
-        let registered = false;
-        // Check for specific augmentation types
-        if (this.isAugmentationType(augmentation, 'processRawData', 'listenToFeed')) {
-            this.registry.sense.push(augmentation);
-            registered = true;
-        }
-        else if (this.isAugmentationType(augmentation, 'establishConnection', 'readData', 'writeData', 'monitorStream')) {
-            this.registry.conduit.push(augmentation);
-            registered = true;
-        }
-        else if (this.isAugmentationType(augmentation, 'reason', 'infer', 'executeLogic')) {
-            this.registry.cognition.push(augmentation);
-            registered = true;
-        }
-        else if (this.isAugmentationType(augmentation, 'storeData', 'retrieveData', 'updateData', 'deleteData', 'listDataKeys')) {
-            this.registry.memory.push(augmentation);
-            registered = true;
-        }
-        else if (this.isAugmentationType(augmentation, 'interpret', 'organize', 'generateVisualization')) {
-            this.registry.perception.push(augmentation);
-            registered = true;
-        }
-        else if (this.isAugmentationType(augmentation, 'processUserInput', 'generateResponse', 'manageContext')) {
-            this.registry.dialog.push(augmentation);
-            registered = true;
-        }
-        else if (this.isAugmentationType(augmentation, 'triggerAction', 'generateOutput', 'interactExternal')) {
-            this.registry.activation.push(augmentation);
-            registered = true;
-        }
-        // Check if the augmentation supports WebSocket
-        if (this.isAugmentationType(augmentation, 'connectWebSocket', 'sendWebSocketMessage', 'onWebSocketMessage', 'closeWebSocket')) {
-            this.registry.webSocket.push(augmentation);
-            registered = true;
-        }
-        // If the augmentation wasn't registered as any known type, throw an error
-        if (!registered) {
-            throw new Error(`Unknown augmentation type: ${augmentation.name}`);
-        }
-        return this;
-    }
-    /**
-     * Unregister an augmentation from the pipeline
-     *
-     * @param augmentationName The name of the augmentation to unregister
-     * @returns The pipeline instance for chaining
-     */
-    unregister(augmentationName) {
-        let found = false;
-        // Remove from all registries
-        for (const type in this.registry) {
-            const typedRegistry = this.registry[type];
-            const index = typedRegistry.findIndex((aug) => aug.name === augmentationName);
-            if (index !== -1) {
-                typedRegistry.splice(index, 1);
-                found = true;
-            }
+        if (Cortex.instance) {
+            return Cortex.instance;
         }
-        return this;
+        Cortex.instance = this;
     }
     /**
-     * Initialize all registered augmentations
-     *
-     * @returns A promise that resolves when all augmentations are initialized
-     */
-    async initialize() {
-        const allAugmentations = this.getAllAugmentations();
-        await Promise.all(allAugmentations.map((augmentation) => augmentation.initialize().catch((error) => {
-            console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-        })));
-    }
-    /**
-     * Shut down all registered augmentations
-     *
-     * @returns A promise that resolves when all augmentations are shut down
-     */
-    async shutDown() {
-        const allAugmentations = this.getAllAugmentations();
-        await Promise.all(allAugmentations.map((augmentation) => augmentation.shutDown().catch((error) => {
-            console.error(`Failed to shut down augmentation ${augmentation.name}:`, error);
-        })));
-    }
-    /**
-     * Execute a sense pipeline
-     *
-     * @param method The method to execute on each sense augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executeSensePipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.sense, method, args, opts);
-    }
-    /**
-     * Execute a conduit pipeline
-     *
-     * @param method The method to execute on each conduit augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executeConduitPipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.conduit, method, args, opts);
-    }
-    /**
-     * Execute a cognition pipeline
-     *
-     * @param method The method to execute on each cognition augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executeCognitionPipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.cognition, method, args, opts);
-    }
-    /**
-     * Execute a memory pipeline
-     *
-     * @param method The method to execute on each memory augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executeMemoryPipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.memory, method, args, opts);
-    }
-    /**
-     * Execute a perception pipeline
-     *
-     * @param method The method to execute on each perception augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executePerceptionPipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.perception, method, args, opts);
-    }
-    /**
-     * Execute a dialog pipeline
-     *
-     * @param method The method to execute on each dialog augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executeDialogPipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.dialog, method, args, opts);
-    }
-    /**
-     * Execute an activation pipeline
-     *
-     * @param method The method to execute on each activation augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
-     */
-    async executeActivationPipeline(method, args, options = {}) {
-        const opts = { ...DEFAULT_PIPELINE_OPTIONS, ...options };
-        return this.executeTypedPipeline(this.registry.activation, method, args, opts);
-    }
-    /**
-     * Get all registered augmentations
-     *
-     * @returns An array of all registered augmentations
-     */
-    getAllAugmentations() {
-        // Create a Set to avoid duplicates (an augmentation might be in multiple registries)
-        const allAugmentations = new Set([
-            ...this.registry.sense,
-            ...this.registry.conduit,
-            ...this.registry.cognition,
-            ...this.registry.memory,
-            ...this.registry.perception,
-            ...this.registry.dialog,
-            ...this.registry.activation,
-            ...this.registry.webSocket
-        ]);
-        // Convert back to array
-        return Array.from(allAugmentations);
-    }
-    /**
-     * Get all augmentations of a specific type
-     *
-     * @param type The type of augmentation to get
-     * @returns An array of all augmentations of the specified type
-     */
-    getAugmentationsByType(type) {
-        switch (type) {
-            case AugmentationType.SENSE:
-                return [...this.registry.sense];
-            case AugmentationType.CONDUIT:
-                return [...this.registry.conduit];
-            case AugmentationType.COGNITION:
-                return [...this.registry.cognition];
-            case AugmentationType.MEMORY:
-                return [...this.registry.memory];
-            case AugmentationType.PERCEPTION:
-                return [...this.registry.perception];
-            case AugmentationType.DIALOG:
-                return [...this.registry.dialog];
-            case AugmentationType.ACTIVATION:
-                return [...this.registry.activation];
-            case AugmentationType.WEBSOCKET:
-                return [...this.registry.webSocket];
-            default:
-                return [];
-        }
-    }
-    /**
-     * Get all available augmentation types
-     *
-     * @returns An array of all augmentation types that have at least one registered augmentation
+     * Get all available augmentation types (returns empty for compatibility)
+     * @deprecated Use brain.augmentations instead
      */
     getAvailableAugmentationTypes() {
-        const availableTypes = [];
-        if (this.registry.sense.length > 0)
-            availableTypes.push(AugmentationType.SENSE);
-        if (this.registry.conduit.length > 0)
-            availableTypes.push(AugmentationType.CONDUIT);
-        if (this.registry.cognition.length > 0)
-            availableTypes.push(AugmentationType.COGNITION);
-        if (this.registry.memory.length > 0)
-            availableTypes.push(AugmentationType.MEMORY);
-        if (this.registry.perception.length > 0)
-            availableTypes.push(AugmentationType.PERCEPTION);
-        if (this.registry.dialog.length > 0)
-            availableTypes.push(AugmentationType.DIALOG);
-        if (this.registry.activation.length > 0)
-            availableTypes.push(AugmentationType.ACTIVATION);
-        if (this.registry.webSocket.length > 0)
-            availableTypes.push(AugmentationType.WEBSOCKET);
-        return availableTypes;
+        console.warn('getAvailableAugmentationTypes is deprecated. Use brain.augmentations instead.');
+        return [];
     }
     /**
-     * Get all WebSocket-supporting augmentations
-     *
-     * @returns An array of all augmentations that support WebSocket connections
+     * Get augmentations by type (returns empty for compatibility)
+     * @deprecated Use brain.augmentations instead
      */
-    getWebSocketAugmentations() {
-        return [...this.registry.webSocket];
+    getAugmentationsByType(type) {
+        console.warn('getAugmentationsByType is deprecated. Use brain.augmentations instead.');
+        return [];
     }
     /**
-     * Check if an augmentation is of a specific type
-     *
-     * @param augmentation The augmentation to check
-     * @param methods The methods that should be present on the augmentation
-     * @returns True if the augmentation is of the specified type
+     * Check if augmentation is enabled (returns false for compatibility)
+     * @deprecated Use brain.augmentations instead
      */
-    isAugmentationType(augmentation, ...methods) {
-        // First check that the augmentation has all the required base methods
-        const baseMethodsExist = ['initialize', 'shutDown', 'getStatus'].every((method) => typeof augmentation[method] === 'function');
-        if (!baseMethodsExist) {
-            return false;
-        }
-        // Then check that it has all the specific methods for this type
-        return methods.every((method) => typeof augmentation[method] === 'function');
+    isAugmentationEnabled(name) {
+        console.warn('isAugmentationEnabled is deprecated. Use brain.augmentations instead.');
+        return false;
     }
     /**
-     * Determines if threading should be used based on options and environment
-     *
-     * @param options The pipeline options
-     * @returns True if threading should be used, false otherwise
+     * List augmentations with status (returns empty for compatibility)
+     * @deprecated Use brain.augmentations instead
      */
-    shouldUseThreading(options) {
-        // If threading is explicitly disabled, don't use it
-        if (options.disableThreading) {
-            return false;
-        }
-        // If threading is explicitly forced, use it if available
-        if (options.forceThreading) {
-            return isThreadingAvailable();
-        }
-        // If in THREADED mode, use threading if available
-        if (options.mode === ExecutionMode.THREADED) {
-            return isThreadingAvailable();
-        }
-        // Otherwise, don't use threading
-        return false;
+    listAugmentationsWithStatus() {
+        console.warn('listAugmentationsWithStatus is deprecated. Use brain.augmentations instead.');
+        return [];
     }
     /**
-     * Execute a pipeline for a specific augmentation type
-     *
-     * @param augmentations The augmentations to execute
-     * @param method The method to execute on each augmentation
-     * @param args The arguments to pass to the method
-     * @param options The pipeline execution options
-     * @returns A promise that resolves with the results from all augmentations
+     * Execute augmentations (compatibility method)
+     * @deprecated Use brain.augmentations.execute instead
      */
-    async executeTypedPipeline(augmentations, method, args, options) {
-        // Filter out disabled augmentations
-        const enabledAugmentations = augmentations.filter((aug) => aug.enabled !== false);
-        if (enabledAugmentations.length === 0) {
-            return [];
-        }
-        // Create a function to execute the method on an augmentation
-        const executeMethod = async (augmentation) => {
-            try {
-                // Create a timeout promise if a timeout is specified
-                const timeoutPromise = options.timeout
-                    ? new Promise((_, reject) => {
-                        setTimeout(() => {
-                            reject(new Error(`Timeout executing ${String(method)} on ${augmentation.name}`));
-                        }, options.timeout);
-                    })
-                    : null;
-                // Check if threading should be used
-                const useThreading = this.shouldUseThreading(options);
-                // Execute the method on the augmentation, using threading if appropriate
-                let methodPromise;
-                if (useThreading) {
-                    // Execute in a separate thread
-                    try {
-                        // Create a function that can be serialized and executed in a worker
-                        const workerFn = (...workerArgs) => {
-                            // This function will be stringified and executed in the worker
-                            // It needs to be self-contained
-                            const augFn = augmentation[method];
-                            return augFn.apply(augmentation, workerArgs);
-                        };
-                        methodPromise = executeInThread(workerFn.toString(), args);
-                    }
-                    catch (threadError) {
-                        console.warn(`Failed to execute in thread, falling back to main thread: ${threadError}`);
-                        // Fall back to executing in the main thread
-                        methodPromise = Promise.resolve(augmentation[method](...args));
-                    }
-                }
-                else {
-                    // Execute in the main thread
-                    methodPromise = Promise.resolve(augmentation[method](...args));
-                }
-                // Race the method promise against the timeout promise if a timeout is specified
-                const result = timeoutPromise
-                    ? await Promise.race([methodPromise, timeoutPromise])
-                    : await methodPromise;
-                return result;
-            }
-            catch (error) {
-                console.error(`Error executing ${String(method)} on ${augmentation.name}:`, error);
-                return {
-                    success: false,
-                    data: null,
-                    error: error instanceof Error ? error.message : String(error)
-                };
-            }
-        };
-        // Execute the pipeline based on the specified mode
-        switch (options.mode) {
-            case ExecutionMode.PARALLEL:
-                // Execute all augmentations in parallel
-                return enabledAugmentations.map(executeMethod);
-            case ExecutionMode.THREADED:
-                // Execute all augmentations in parallel with threading enabled
-                // Force threading for this mode
-                const threadedOptions = { ...options, forceThreading: true };
-                // Create a new executeMethod function that uses the threaded options
-                const executeMethodThreaded = async (augmentation) => {
-                    // Save the original options
-                    const originalOptions = options;
-                    // Set the options to the threaded options
-                    options = threadedOptions;
-                    // Execute the method
-                    const result = await executeMethod(augmentation);
-                    // Restore the original options
-                    options = originalOptions;
-                    return result;
-                };
-                return enabledAugmentations.map(executeMethodThreaded);
-            case ExecutionMode.FIRST_SUCCESS:
-                // Execute augmentations sequentially until one succeeds
-                for (const augmentation of enabledAugmentations) {
-                    const resultPromise = executeMethod(augmentation);
-                    const result = await resultPromise;
-                    if (result.success) {
-                        return [resultPromise];
-                    }
-                }
-                return [];
-            case ExecutionMode.FIRST_RESULT:
-                // Execute augmentations sequentially until one returns a result
-                for (const augmentation of enabledAugmentations) {
-                    const resultPromise = executeMethod(augmentation);
-                    const result = await resultPromise;
-                    if (result.success && result.data) {
-                        return [resultPromise];
-                    }
-                }
-                return [];
-            case ExecutionMode.SEQUENTIAL:
-            default:
-                // Execute augmentations sequentially
-                const results = [];
-                for (const augmentation of enabledAugmentations) {
-                    const resultPromise = executeMethod(augmentation);
-                    results.push(resultPromise);
-                    // Check if we need to stop on error
-                    if (options.stopOnError) {
-                        const result = await resultPromise;
-                        if (!result.success) {
-                            break;
-                        }
-                    }
-                }
-                return results;
-        }
+    async executeAugmentations(operation, data, options) {
+        console.warn('executeAugmentations is deprecated. Use brain.augmentations.execute instead.');
+        return data;
     }
     /**
-     * Enable an augmentation by name
-     *
-     * @param name The name of the augmentation to enable
-     * @returns True if augmentation was found and enabled
+     * Enable augmentation (compatibility method)
+     * @deprecated Use brain.augmentations instead
      */
     enableAugmentation(name) {
-        for (const type of Object.keys(this.registry)) {
-            const augmentation = this.registry[type].find(aug => aug.name === name);
-            if (augmentation) {
-                augmentation.enabled = true;
-                return true;
-            }
-        }
+        console.warn('enableAugmentation is deprecated. Use brain.augmentations instead.');
         return false;
     }
     /**
-     * Disable an augmentation by name
-     *
-     * @param name The name of the augmentation to disable
-     * @returns True if augmentation was found and disabled
+     * Disable augmentation (compatibility method)
+     * @deprecated Use brain.augmentations instead
      */
     disableAugmentation(name) {
-        for (const type of Object.keys(this.registry)) {
-            const augmentation = this.registry[type].find(aug => aug.name === name);
-            if (augmentation) {
-                augmentation.enabled = false;
-                return true;
-            }
-        }
+        console.warn('disableAugmentation is deprecated. Use brain.augmentations instead.');
         return false;
     }
     /**
-     * Check if an augmentation is enabled
-     *
-     * @param name The name of the augmentation to check
-     * @returns True if augmentation is found and enabled, false otherwise
+     * Register augmentation (compatibility method)
+     * @deprecated Use brain.augmentations.register instead
      */
-    isAugmentationEnabled(name) {
-        for (const type of Object.keys(this.registry)) {
-            const augmentation = this.registry[type].find(aug => aug.name === name);
-            if (augmentation) {
-                return augmentation.enabled;
-            }
-        }
-        return false;
+    register(augmentation) {
+        console.warn('register is deprecated. Use brain.augmentations.register instead.');
     }
     /**
-     * Get all augmentations with their enabled status
-     *
-     * @returns Array of augmentations with name, type, and enabled status
+     * Unregister augmentation (compatibility method)
+     * @deprecated Use brain.augmentations instead
      */
-    listAugmentationsWithStatus() {
-        const result = [];
-        for (const [type, augmentations] of Object.entries(this.registry)) {
-            for (const aug of augmentations) {
-                result.push({
-                    name: aug.name,
-                    type: type,
-                    enabled: aug.enabled,
-                    description: aug.description
-                });
-            }
-        }
-        return result;
+    unregister(name) {
+        console.warn('unregister is deprecated. Use brain.augmentations instead.');
+        return false;
     }
     /**
-     * Enable all augmentations of a specific type
-     *
-     * @param type The type of augmentations to enable
-     * @returns Number of augmentations enabled
+     * Enable augmentation type (compatibility method)
+     * @deprecated Use brain.augmentations instead
      */
     enableAugmentationType(type) {
-        let count = 0;
-        for (const aug of this.registry[type]) {
-            aug.enabled = true;
-            count++;
-        }
-        return count;
+        console.warn('enableAugmentationType is deprecated. Use brain.augmentations instead.');
+        return 0;
     }
     /**
-     * Disable all augmentations of a specific type
-     *
-     * @param type The type of augmentations to disable
-     * @returns Number of augmentations disabled
+     * Disable augmentation type (compatibility method)
+     * @deprecated Use brain.augmentations instead
      */
     disableAugmentationType(type) {
-        let count = 0;
-        for (const aug of this.registry[type]) {
-            aug.enabled = false;
-            count++;
-        }
-        return count;
+        console.warn('disableAugmentationType is deprecated. Use brain.augmentations instead.');
+        return 0;
     }
 }
 // Create and export a default instance of the cortex
@@ -571,4 +121,6 @@ export const cortex = new Cortex();
 // Backward compatibility exports
 export const AugmentationPipeline = Cortex;
 export const augmentationPipeline = cortex;
+// Export types for compatibility (avoid duplicate export)
+// PipelineOptions already exported above
 //# sourceMappingURL=augmentationPipeline.js.map