@soulcraft/brainy 1.5.0 → 2.0.1

package/dist/augmentationRegistry.d.ts

@@ -1,47 +1,38 @@
 /**
- * Augmentation Registry
+ * Augmentation Registry (Compatibility Layer)
  *
- * This module provides a registry for augmentations that are loaded at build time.
- * It replaces the dynamic loading mechanism in pluginLoader.ts.
+ * @deprecated This module provides backward compatibility for old augmentation
+ * loading code. All new code should use the AugmentationRegistry class directly
+ * on BrainyData instances.
  */
-import { IPipeline } from './types/pipelineTypes.js';
-import { AugmentationType, IAugmentation } from './types/augmentations.js';
+import { BrainyAugmentation } from './types/augmentations.js';
 /**
- * Sets the default pipeline instance
- * This function should be called from pipeline.ts after the pipeline is created
+ * Registry of all available augmentations (for compatibility)
+ * @deprecated Use brain.augmentations instead
  */
-export declare function setDefaultPipeline(pipeline: IPipeline): void;
+export declare const availableAugmentations: any[];
 /**
- * Registry of all available augmentations
+ * Compatibility wrapper for registerAugmentation
+ * @deprecated Use brain.augmentations.register instead
  */
-export declare const availableAugmentations: IAugmentation[];
+export declare function registerAugmentation<T extends BrainyAugmentation>(augmentation: T): T;
 /**
- * Registers an augmentation with the registry
- *
- * @param augmentation The augmentation to register
- * @returns The augmentation that was registered
+ * Sets the default pipeline instance (compatibility)
+ * @deprecated Use brain.augmentations instead
  */
-export declare function registerAugmentation<T extends IAugmentation>(augmentation: T): T;
+export declare function setDefaultPipeline(pipeline: any): void;
 /**
- * Initializes the augmentation pipeline with all registered augmentations
- *
- * @param pipeline Optional custom pipeline to use instead of the default
- * @returns The pipeline that was initialized
- * @throws Error if no pipeline is provided and the default pipeline hasn't been set
+ * Initializes the augmentation pipeline (compatibility)
+ * @deprecated Use brain.augmentations instead
  */
-export declare function initializeAugmentationPipeline(pipelineInstance?: IPipeline): IPipeline;
+export declare function initializeAugmentationPipeline(pipelineInstance?: any): any;
 /**
- * Enables or disables an augmentation by name
- *
- * @param name The name of the augmentation to enable/disable
- * @param enabled Whether to enable or disable the augmentation
- * @returns True if the augmentation was found and updated, false otherwise
+ * 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
- *
- * @param type The type of augmentation to get
- * @returns An array of all augmentations of the specified type
+ * Gets all augmentations of a specific type (compatibility)
+ * @deprecated Use brain.augmentations instead
  */
-export declare function getAugmentationsByType(type: AugmentationType): IAugmentation[];
+export declare function getAugmentationsByType(type: any): any[];

package/dist/augmentationRegistry.js

@@ -1,105 +1,54 @@
 /**
- * Augmentation Registry
+ * Augmentation Registry (Compatibility Layer)
  *
- * This module provides a registry for augmentations that are loaded at build time.
- * It replaces the dynamic loading mechanism in pluginLoader.ts.
+ * @deprecated This module provides backward compatibility for old augmentation
+ * loading code. All new code should use the AugmentationRegistry class directly
+ * on BrainyData instances.
  */
-import { AugmentationType } from './types/augmentations.js';
-// Forward declaration of the pipeline instance to avoid circular dependency
-// The actual pipeline will be provided when initializeAugmentationPipeline is called
-let defaultPipeline = null;
 /**
- * Sets the default pipeline instance
- * This function should be called from pipeline.ts after the pipeline is created
- */
-export function setDefaultPipeline(pipeline) {
-    defaultPipeline = pipeline;
-}
-/**
- * Registry of all available augmentations
+ * Registry of all available augmentations (for compatibility)
+ * @deprecated Use brain.augmentations instead
  */
 export const availableAugmentations = [];
 /**
- * Registers an augmentation with the registry
- *
- * @param augmentation The augmentation to register
- * @returns The augmentation that was registered
+ * Compatibility wrapper for registerAugmentation
+ * @deprecated Use brain.augmentations.register instead
  */
 export function registerAugmentation(augmentation) {
-    // Set enabled to true by default if not specified
-    if (augmentation.enabled === undefined) {
-        augmentation.enabled = true;
-    }
-    // Add to the registry
+    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;
 }
 /**
- * Initializes the augmentation pipeline with all registered augmentations
- *
- * @param pipeline Optional custom pipeline to use instead of the default
- * @returns The pipeline that was initialized
- * @throws Error if no pipeline is provided and the default pipeline hasn't been set
+ * 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) {
-    // Use the provided pipeline or fall back to the default
-    const pipeline = pipelineInstance || defaultPipeline;
-    if (!pipeline) {
-        throw new Error('No pipeline provided and default pipeline not set. Call setDefaultPipeline first.');
-    }
-    // Register all augmentations with the pipeline
-    for (const augmentation of availableAugmentations) {
-        if (augmentation.enabled) {
-            pipeline.register(augmentation);
-        }
-    }
-    return pipeline;
+    console.warn('initializeAugmentationPipeline is deprecated. Use brain.augmentations instead.');
+    return pipelineInstance || {};
 }
 /**
- * Enables or disables an augmentation by name
- *
- * @param name The name of the augmentation to enable/disable
- * @param enabled Whether to enable or disable the augmentation
- * @returns True if the augmentation was found and updated, false otherwise
+ * Enables or disables an augmentation by name (compatibility)
+ * @deprecated Use brain.augmentations instead
  */
 export function setAugmentationEnabled(name, enabled) {
-    const augmentation = availableAugmentations.find(aug => aug.name === name);
-    if (augmentation) {
-        augmentation.enabled = enabled;
-        return true;
-    }
+    console.warn('setAugmentationEnabled is deprecated. Use brain.augmentations instead.');
     return false;
 }
 /**
- * Gets all augmentations of a specific type
- *
- * @param type The type of augmentation to get
- * @returns An array of all augmentations of the specified type
+ * Gets all augmentations of a specific type (compatibility)
+ * @deprecated Use brain.augmentations instead
  */
 export function getAugmentationsByType(type) {
-    return availableAugmentations.filter(aug => {
-        // Check if the augmentation is of the specified type
-        // This is a simplified check and may need to be updated based on how types are determined
-        switch (type) {
-            case AugmentationType.SENSE:
-                return 'processRawData' in aug && 'listenToFeed' in aug;
-            case AugmentationType.CONDUIT:
-                return 'establishConnection' in aug && 'readData' in aug && 'writeData' in aug;
-            case AugmentationType.COGNITION:
-                return 'reason' in aug && 'infer' in aug && 'executeLogic' in aug;
-            case AugmentationType.MEMORY:
-                return 'storeData' in aug && 'retrieveData' in aug && 'updateData' in aug;
-            case AugmentationType.PERCEPTION:
-                return 'interpret' in aug && 'organize' in aug && 'generateVisualization' in aug;
-            case AugmentationType.DIALOG:
-                return 'processUserInput' in aug && 'generateResponse' in aug && 'manageContext' in aug;
-            case AugmentationType.ACTIVATION:
-                return 'triggerAction' in aug && 'generateOutput' in aug && 'interactExternal' in aug;
-            case AugmentationType.WEBSOCKET:
-                return 'connectWebSocket' in aug && 'sendWebSocketMessage' in aug && 'onWebSocketMessage' in aug;
-            default:
-                return false;
-        }
-    });
+    console.warn('getAugmentationsByType is deprecated. Use brain.augmentations instead.');
+    return [];
 }
 //# sourceMappingURL=augmentationRegistry.js.map

package/dist/augmentations/apiServerAugmentation.d.ts

@@ -0,0 +1,108 @@
+/**
+ * API Server Augmentation - Universal API Exposure
+ *
+ * 🌐 Exposes Brainy through REST, WebSocket, and MCP
+ * 🔌 Works in Node.js, Deno, and Service Workers
+ * 🚀 Single augmentation for all API needs
+ *
+ * This unifies and replaces:
+ * - BrainyMCPBroadcast (Node-specific server)
+ * - WebSocketConduitAugmentation (client connections)
+ * - Future REST API implementations
+ */
+import { BaseAugmentation } from './brainyAugmentation.js';
+export interface APIServerConfig {
+    enabled?: boolean;
+    port?: number;
+    mcpPort?: number;
+    wsPort?: number;
+    host?: string;
+    cors?: {
+        origin?: string | string[];
+        credentials?: boolean;
+    };
+    auth?: {
+        required?: boolean;
+        apiKeys?: string[];
+        bearerTokens?: string[];
+    };
+    rateLimit?: {
+        windowMs?: number;
+        max?: number;
+    };
+    ssl?: {
+        cert?: string;
+        key?: string;
+    };
+}
+/**
+ * Unified API Server Augmentation
+ * Exposes Brainy through multiple protocols
+ */
+export declare class APIServerAugmentation extends BaseAugmentation {
+    readonly name = "api-server";
+    readonly timing: "after";
+    readonly operations: ("all")[];
+    readonly priority = 5;
+    private config;
+    private mcpService?;
+    private httpServer?;
+    private wsServer?;
+    private clients;
+    private operationHistory;
+    private maxHistorySize;
+    constructor(config?: APIServerConfig);
+    protected onInitialize(): Promise<void>;
+    /**
+     * Start Node.js server with Express
+     */
+    private startNodeServer;
+    /**
+     * Setup REST API routes
+     */
+    private setupRESTRoutes;
+    /**
+     * Setup WebSocket server
+     */
+    private setupWebSocketServer;
+    /**
+     * Handle WebSocket message
+     */
+    private handleWebSocketMessage;
+    /**
+     * Execute augmentation - broadcast operations to clients
+     */
+    execute<T = any>(operation: string, params: any, next: () => Promise<T>): Promise<T>;
+    /**
+     * Auth middleware for Express
+     */
+    private authMiddleware;
+    /**
+     * Rate limiting middleware
+     */
+    private rateLimitMiddleware;
+    /**
+     * Sanitize parameters before broadcasting
+     */
+    private sanitizeParams;
+    /**
+     * Send heartbeats to all connected clients
+     */
+    private sendHeartbeats;
+    /**
+     * Start Deno server
+     */
+    private startDenoServer;
+    /**
+     * Start Service Worker (for browser)
+     */
+    private startServiceWorker;
+    /**
+     * Shutdown the server
+     */
+    protected onShutdown(): Promise<void>;
+}
+/**
+ * Helper function to create and configure API server
+ */
+export declare function createAPIServer(config?: APIServerConfig): APIServerAugmentation;