@soulcraft/brainy 3.20.1 → 3.20.3

package/dist/augmentationFactory.js

@@ -1,342 +0,0 @@
-/**
- * Augmentation Factory
- *
- * This module provides a simplified factory for creating augmentations with minimal boilerplate.
- * It reduces the complexity of creating and using augmentations by providing a fluent API
- * and handling common patterns automatically.
- */
-import { registerAugmentation } from './augmentationRegistry.js';
-/**
- * Base class for all augmentations created with the factory
- * Handles common functionality like initialization, shutdown, and status
- */
-class BaseAugmentation {
-    constructor(options) {
-        this.enabled = true;
-        this.isInitialized = false;
-        this.name = options.name;
-        this.description = options.description || `${options.name} augmentation`;
-        this.enabled = options.enabled !== false;
-    }
-    async initialize() {
-        if (this.isInitialized)
-            return;
-        this.isInitialized = true;
-    }
-    async shutDown() {
-        this.isInitialized = false;
-    }
-    async getStatus() {
-        return this.isInitialized ? 'active' : 'inactive';
-    }
-    async ensureInitialized() {
-        if (!this.isInitialized) {
-            await this.initialize();
-        }
-    }
-}
-/**
- * Factory for creating sense augmentations
- */
-export function createSenseAugmentation(options) {
-    const augmentation = new BaseAugmentation(options);
-    // Implement the sense augmentation methods
-    augmentation.processRawData = async (rawData, dataType) => {
-        await augmentation.ensureInitialized();
-        if (options.processRawData) {
-            const result = options.processRawData(rawData, dataType);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: { nouns: [], verbs: [] },
-            error: 'processRawData not implemented'
-        };
-    };
-    augmentation.listenToFeed = async (feedUrl, callback) => {
-        await augmentation.ensureInitialized();
-        if (options.listenToFeed) {
-            return options.listenToFeed(feedUrl, callback);
-        }
-        throw new Error('listenToFeed not implemented');
-    };
-    // Auto-register if requested
-    if (options.autoRegister) {
-        registerAugmentation(augmentation);
-        // Auto-initialize if requested
-        if (options.autoInitialize) {
-            augmentation.initialize().catch((error) => {
-                console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-            });
-        }
-    }
-    return augmentation;
-}
-/**
- * Factory for creating conduit augmentations
- */
-export function createConduitAugmentation(options) {
-    const augmentation = new BaseAugmentation(options);
-    // Implement the conduit augmentation methods
-    augmentation.establishConnection = async (targetSystemId, config) => {
-        await augmentation.ensureInitialized();
-        if (options.establishConnection) {
-            const result = options.establishConnection(targetSystemId, config);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'establishConnection not implemented'
-        };
-    };
-    augmentation.readData = async (query, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.readData) {
-            const result = options.readData(query, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'readData not implemented'
-        };
-    };
-    augmentation.writeData = async (data, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.writeData) {
-            const result = options.writeData(data, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'writeData not implemented'
-        };
-    };
-    augmentation.monitorStream = async (streamId, callback) => {
-        await augmentation.ensureInitialized();
-        if (options.monitorStream) {
-            return options.monitorStream(streamId, callback);
-        }
-        throw new Error('monitorStream not implemented');
-    };
-    // Auto-register if requested
-    if (options.autoRegister) {
-        registerAugmentation(augmentation);
-        // Auto-initialize if requested
-        if (options.autoInitialize) {
-            augmentation.initialize().catch((error) => {
-                console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-            });
-        }
-    }
-    return augmentation;
-}
-/**
- * Factory for creating memory augmentations
- */
-export function createMemoryAugmentation(options) {
-    const augmentation = new BaseAugmentation(options);
-    // Implement the memory augmentation methods
-    augmentation.storeData = async (key, data, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.storeData) {
-            const result = options.storeData(key, data, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: false,
-            error: 'storeData not implemented'
-        };
-    };
-    augmentation.retrieveData = async (key, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.retrieveData) {
-            const result = options.retrieveData(key, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: null,
-            error: 'retrieveData not implemented'
-        };
-    };
-    augmentation.updateData = async (key, data, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.updateData) {
-            const result = options.updateData(key, data, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: false,
-            error: 'updateData not implemented'
-        };
-    };
-    augmentation.deleteData = async (key, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.deleteData) {
-            const result = options.deleteData(key, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: false,
-            error: 'deleteData not implemented'
-        };
-    };
-    augmentation.listDataKeys = async (pattern, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.listDataKeys) {
-            const result = options.listDataKeys(pattern, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: [],
-            error: 'listDataKeys not implemented'
-        };
-    };
-    augmentation.search = async (query, k, opts) => {
-        await augmentation.ensureInitialized();
-        if (options.search) {
-            const result = options.search(query, k, opts);
-            return result instanceof Promise ? await result : result;
-        }
-        return {
-            success: false,
-            data: [],
-            error: 'search not implemented'
-        };
-    };
-    // Auto-register if requested
-    if (options.autoRegister) {
-        registerAugmentation(augmentation);
-        // Auto-initialize if requested
-        if (options.autoInitialize) {
-            augmentation.initialize().catch((error) => {
-                console.error(`Failed to initialize augmentation ${augmentation.name}:`, error);
-            });
-        }
-    }
-    return augmentation;
-}
-/**
- * Factory for creating WebSocket-enabled augmentations
- * This can be combined with other augmentation factories to create WebSocket-enabled versions
- */
-export function addWebSocketSupport(augmentation, options) {
-    const wsAugmentation = augmentation;
-    // Add WebSocket methods
-    wsAugmentation.connectWebSocket = async (url, protocols) => {
-        await augmentation.ensureInitialized?.();
-        if (options.connectWebSocket) {
-            return options.connectWebSocket(url, protocols);
-        }
-        throw new Error('connectWebSocket not implemented');
-    };
-    wsAugmentation.sendWebSocketMessage = async (connectionId, data) => {
-        await augmentation.ensureInitialized?.();
-        if (options.sendWebSocketMessage) {
-            return options.sendWebSocketMessage(connectionId, data);
-        }
-        throw new Error('sendWebSocketMessage not implemented');
-    };
-    wsAugmentation.onWebSocketMessage = async (connectionId, callback) => {
-        await augmentation.ensureInitialized?.();
-        if (options.onWebSocketMessage) {
-            return options.onWebSocketMessage(connectionId, callback);
-        }
-        throw new Error('onWebSocketMessage not implemented');
-    };
-    wsAugmentation.offWebSocketMessage = async (connectionId, callback) => {
-        await augmentation.ensureInitialized?.();
-        if (options.offWebSocketMessage) {
-            return options.offWebSocketMessage(connectionId, callback);
-        }
-        throw new Error('offWebSocketMessage not implemented');
-    };
-    wsAugmentation.closeWebSocket = async (connectionId, code, reason) => {
-        await augmentation.ensureInitialized?.();
-        if (options.closeWebSocket) {
-            return options.closeWebSocket(connectionId, code, reason);
-        }
-        throw new Error('closeWebSocket not implemented');
-    };
-    return wsAugmentation;
-}
-/**
- * Simplified function to execute an augmentation method with automatic error handling
- * This provides a more concise way to execute augmentation methods compared to the full pipeline
- */
-export async function executeAugmentation(augmentation, method, ...args) {
-    try {
-        if (!augmentation.enabled) {
-            return {
-                success: false,
-                data: null,
-                error: `Augmentation ${augmentation.name} is disabled`
-            };
-        }
-        if (typeof augmentation[method] !== 'function') {
-            return {
-                success: false,
-                data: null,
-                error: `Method ${method} not found on augmentation ${augmentation.name}`
-            };
-        }
-        const result = await augmentation[method](...args);
-        return result;
-    }
-    catch (error) {
-        console.error(`Error executing ${method} on ${augmentation.name}:`, error);
-        return {
-            success: false,
-            data: null,
-            error: error instanceof Error ? error.message : String(error)
-        };
-    }
-}
-/**
- * Dynamically load augmentations from a module at runtime
- * This allows for lazy-loading augmentations when needed instead of at build time
- */
-export async function loadAugmentationModule(modulePromise, options = {}) {
-    try {
-        const module = await modulePromise;
-        const augmentations = [];
-        // Extract augmentations from the module
-        for (const key in module) {
-            const exported = module[key];
-            // Skip non-objects and null
-            if (!exported || typeof exported !== 'object') {
-                continue;
-            }
-            // Check if it's an augmentation
-            if (typeof exported.name === 'string' &&
-                typeof exported.initialize === 'function' &&
-                typeof exported.shutDown === 'function' &&
-                typeof exported.getStatus === 'function') {
-                augmentations.push(exported);
-                // Auto-register if requested
-                if (options.autoRegister) {
-                    registerAugmentation(exported);
-                    // Auto-initialize if requested
-                    if (options.autoInitialize) {
-                        exported.initialize().catch((error) => {
-                            console.error(`Failed to initialize augmentation ${exported.name}:`, error);
-                        });
-                    }
-                }
-            }
-        }
-        return augmentations;
-    }
-    catch (error) {
-        console.error('Error loading augmentation module:', error);
-        return [];
-    }
-}
-//# sourceMappingURL=augmentationFactory.js.map

package/dist/augmentationRegistry.d.ts

@@ -1,38 +0,0 @@
-/**
- * Augmentation Registry (Compatibility Layer)
- *
- * @deprecated This module provides backward compatibility for old augmentation
- * loading code. All new code should use the AugmentationRegistry class directly
- * on Brainy instances.
- */
-import { BrainyAugmentation } from './types/augmentations.js';
-/**
- * Registry of all available augmentations (for compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export declare const availableAugmentations: any[];
-/**
- * Compatibility wrapper for registerAugmentation
- * @deprecated Use brain.augmentations.register instead
- */
-export declare function registerAugmentation<T extends BrainyAugmentation>(augmentation: T): T;
-/**
- * Sets the default pipeline instance (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export declare function setDefaultPipeline(pipeline: any): void;
-/**
- * Initializes the augmentation pipeline (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export declare function initializeAugmentationPipeline(pipelineInstance?: any): any;
-/**
- * Enables or disables an augmentation by name (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export declare function setAugmentationEnabled(name: string, enabled: boolean): boolean;
-/**
- * Gets all augmentations of a specific type (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export declare function getAugmentationsByType(type: any): any[];

package/dist/augmentationRegistry.js

@@ -1,54 +0,0 @@
-/**
- * Augmentation Registry (Compatibility Layer)
- *
- * @deprecated This module provides backward compatibility for old augmentation
- * loading code. All new code should use the AugmentationRegistry class directly
- * on Brainy instances.
- */
-/**
- * Registry of all available augmentations (for compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export const availableAugmentations = [];
-/**
- * Compatibility wrapper for registerAugmentation
- * @deprecated Use brain.augmentations.register instead
- */
-export function registerAugmentation(augmentation) {
-    console.warn('registerAugmentation is deprecated. Use brain.augmentations.register instead.');
-    // For compatibility, just add to the list (but it won't actually do anything)
-    availableAugmentations.push(augmentation);
-    return augmentation;
-}
-/**
- * Sets the default pipeline instance (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export function setDefaultPipeline(pipeline) {
-    console.warn('setDefaultPipeline is deprecated. Use brain.augmentations instead.');
-}
-/**
- * Initializes the augmentation pipeline (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export function initializeAugmentationPipeline(pipelineInstance) {
-    console.warn('initializeAugmentationPipeline is deprecated. Use brain.augmentations instead.');
-    return pipelineInstance || {};
-}
-/**
- * Enables or disables an augmentation by name (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export function setAugmentationEnabled(name, enabled) {
-    console.warn('setAugmentationEnabled is deprecated. Use brain.augmentations instead.');
-    return false;
-}
-/**
- * Gets all augmentations of a specific type (compatibility)
- * @deprecated Use brain.augmentations instead
- */
-export function getAugmentationsByType(type) {
-    console.warn('getAugmentationsByType is deprecated. Use brain.augmentations instead.');
-    return [];
-}
-//# sourceMappingURL=augmentationRegistry.js.map

package/dist/augmentationRegistryLoader.d.ts

@@ -1,146 +0,0 @@
-/**
- * Augmentation Registry Loader
- *
- * This module provides functionality for loading augmentation registrations
- * at build time. It's designed to be used with build tools like webpack or rollup
- * to automatically discover and register augmentations.
- */
-import { IAugmentation } from './types/augmentations.js';
-/**
- * Options for the augmentation registry loader
- */
-export interface AugmentationRegistryLoaderOptions {
-    /**
-     * Whether to automatically initialize the augmentations after loading
-     * @default false
-     */
-    autoInitialize?: boolean;
-    /**
-     * Whether to log debug information during loading
-     * @default false
-     */
-    debug?: boolean;
-}
-/**
- * Result of loading augmentations
- */
-export interface AugmentationLoadResult {
-    /**
-     * The augmentations that were loaded
-     */
-    augmentations: IAugmentation[];
-    /**
-     * Any errors that occurred during loading
-     */
-    errors: Error[];
-}
-/**
- * Loads augmentations from the specified modules
- *
- * This function is designed to be used with build tools like webpack or rollup
- * to automatically discover and register augmentations.
- *
- * @param modules An object containing modules with augmentations to register
- * @param options Options for the loader
- * @returns A promise that resolves with the result of loading the augmentations
- *
- * @example
- * ```typescript
- * // webpack.config.js
- * const { AugmentationRegistryPlugin } = require('brainy/dist/webpack');
- *
- * module.exports = {
- *   // ... other webpack config
- *   plugins: [
- *     new AugmentationRegistryPlugin({
- *       // Pattern to match files containing augmentations
- *       pattern: /augmentation\.js$/,
- *       // Options for the loader
- *       options: {
- *         autoInitialize: true,
- *         debug: true
- *       }
- *     })
- *   ]
- * };
- * ```
- */
-export declare function loadAugmentationsFromModules(modules: Record<string, any>, options?: AugmentationRegistryLoaderOptions): Promise<AugmentationLoadResult>;
-/**
- * Creates a webpack plugin for automatically loading augmentations
- *
- * @param options Options for the plugin
- * @returns A webpack plugin
- *
- * @example
- * ```typescript
- * // webpack.config.js
- * const { createAugmentationRegistryPlugin } = require('brainy/dist/webpack');
- *
- * module.exports = {
- *   // ... other webpack config
- *   plugins: [
- *     createAugmentationRegistryPlugin({
- *       pattern: /augmentation\.js$/,
- *       options: {
- *         autoInitialize: true,
- *         debug: true
- *       }
- *     })
- *   ]
- * };
- * ```
- */
-export declare function createAugmentationRegistryPlugin(options: {
-    /**
-     * Pattern to match files containing augmentations
-     */
-    pattern: RegExp;
-    /**
-     * Options for the loader
-     */
-    options?: AugmentationRegistryLoaderOptions;
-}): {
-    name: string;
-    pattern: RegExp;
-    options: AugmentationRegistryLoaderOptions;
-};
-/**
- * Creates a rollup plugin for automatically loading augmentations
- *
- * @param options Options for the plugin
- * @returns A rollup plugin
- *
- * @example
- * ```typescript
- * // rollup.config.js
- * import { createAugmentationRegistryRollupPlugin } from 'brainy/dist/rollup';
- *
- * export default {
- *   // ... other rollup config
- *   plugins: [
- *     createAugmentationRegistryRollupPlugin({
- *       pattern: /augmentation\.js$/,
- *       options: {
- *         autoInitialize: true,
- *         debug: true
- *       }
- *     })
- *   ]
- * };
- * ```
- */
-export declare function createAugmentationRegistryRollupPlugin(options: {
-    /**
-     * Pattern to match files containing augmentations
-     */
-    pattern: RegExp;
-    /**
-     * Options for the loader
-     */
-    options?: AugmentationRegistryLoaderOptions;
-}): {
-    name: string;
-    pattern: RegExp;
-    options: AugmentationRegistryLoaderOptions;
-};