@soulcraft/brainy 3.0.0 → 3.0.1

package/dist/augmentationPipeline.d.ts

@@ -6,7 +6,6 @@
  *
  * This minimal implementation redirects to the new AugmentationRegistry system.
  */
-import { BrainyAugmentation } from './types/augmentations.js';
 /**
  * Execution mode for pipeline operations
  */
@@ -33,66 +32,6 @@ export interface PipelineOptions {
 export declare class Cortex {
     private static instance?;
     constructor();
-    /**
-     * Get all available augmentation types (returns empty for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    getAvailableAugmentationTypes(): string[];
-    /**
-     * Get augmentations by type (returns empty for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    getAugmentationsByType(type: string): BrainyAugmentation[];
-    /**
-     * Check if augmentation is enabled (returns false for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    isAugmentationEnabled(name: string): boolean;
-    /**
-     * List augmentations with status (returns empty for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    listAugmentationsWithStatus(): Array<{
-        name: string;
-        type: string;
-        enabled: boolean;
-        description: string;
-    }>;
-    /**
-     * Execute augmentations (compatibility method)
-     * @deprecated Use brain.augmentations.execute instead
-     */
-    executeAugmentations<T>(operation: string, data: any, options?: PipelineOptions): Promise<T>;
-    /**
-     * Enable augmentation (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    enableAugmentation(name: string): boolean;
-    /**
-     * Disable augmentation (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    disableAugmentation(name: string): boolean;
-    /**
-     * Register augmentation (compatibility method)
-     * @deprecated Use brain.augmentations.register instead
-     */
-    register(augmentation: BrainyAugmentation): void;
-    /**
-     * Unregister augmentation (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    unregister(name: string): boolean;
-    /**
-     * Enable augmentation type (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    enableAugmentationType(type: string): number;
-    /**
-     * Disable augmentation type (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    disableAugmentationType(type: string): number;
 }
 export declare const cortex: Cortex;
 export declare const AugmentationPipeline: typeof Cortex;

package/dist/augmentationPipeline.js

@@ -28,93 +28,6 @@ export class Cortex {
         }
         Cortex.instance = this;
     }
-    /**
-     * Get all available augmentation types (returns empty for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    getAvailableAugmentationTypes() {
-        console.warn('getAvailableAugmentationTypes is deprecated. Use brain.augmentations instead.');
-        return [];
-    }
-    /**
-     * Get augmentations by type (returns empty for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    getAugmentationsByType(type) {
-        console.warn('getAugmentationsByType is deprecated. Use brain.augmentations instead.');
-        return [];
-    }
-    /**
-     * Check if augmentation is enabled (returns false for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    isAugmentationEnabled(name) {
-        console.warn('isAugmentationEnabled is deprecated. Use brain.augmentations instead.');
-        return false;
-    }
-    /**
-     * List augmentations with status (returns empty for compatibility)
-     * @deprecated Use brain.augmentations instead
-     */
-    listAugmentationsWithStatus() {
-        console.warn('listAugmentationsWithStatus is deprecated. Use brain.augmentations instead.');
-        return [];
-    }
-    /**
-     * Execute augmentations (compatibility method)
-     * @deprecated Use brain.augmentations.execute instead
-     */
-    async executeAugmentations(operation, data, options) {
-        console.warn('executeAugmentations is deprecated. Use brain.augmentations.execute instead.');
-        return data;
-    }
-    /**
-     * Enable augmentation (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    enableAugmentation(name) {
-        console.warn('enableAugmentation is deprecated. Use brain.augmentations instead.');
-        return false;
-    }
-    /**
-     * Disable augmentation (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    disableAugmentation(name) {
-        console.warn('disableAugmentation is deprecated. Use brain.augmentations instead.');
-        return false;
-    }
-    /**
-     * Register augmentation (compatibility method)
-     * @deprecated Use brain.augmentations.register instead
-     */
-    register(augmentation) {
-        console.warn('register is deprecated. Use brain.augmentations.register instead.');
-    }
-    /**
-     * Unregister augmentation (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    unregister(name) {
-        console.warn('unregister is deprecated. Use brain.augmentations instead.');
-        return false;
-    }
-    /**
-     * Enable augmentation type (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    enableAugmentationType(type) {
-        console.warn('enableAugmentationType is deprecated. Use brain.augmentations instead.');
-        return 0;
-    }
-    /**
-     * Disable augmentation type (compatibility method)
-     * @deprecated Use brain.augmentations instead
-     */
-    disableAugmentationType(type) {
-        console.warn('disableAugmentationType is deprecated. Use brain.augmentations instead.');
-        return 0;
-    }
 }
 // Create and export a default instance of the cortex
 export const cortex = new Cortex();

package/dist/augmentationRegistry.d.ts

@@ -3,7 +3,7 @@
  *
  * @deprecated This module provides backward compatibility for old augmentation
  * loading code. All new code should use the AugmentationRegistry class directly
- * on BrainyData instances.
+ * on Brainy instances.
  */
 import { BrainyAugmentation } from './types/augmentations.js';
 /**

package/dist/augmentationRegistry.js

@@ -3,7 +3,7 @@
  *
  * @deprecated This module provides backward compatibility for old augmentation
  * loading code. All new code should use the AugmentationRegistry class directly
- * on BrainyData instances.
+ * on Brainy instances.
  */
 /**
  * Registry of all available augmentations (for compatibility)

package/dist/augmentations/apiServerAugmentation.d.ts

@@ -45,13 +45,14 @@ export declare class APIServerAugmentation extends BaseAugmentation {
     readonly metadata: "readonly";
     readonly operations: ("all")[];
     readonly priority = 5;
-    private config;
+    protected config: APIServerConfig;
     private mcpService?;
     private httpServer?;
     private wsServer?;
     private clients;
     private operationHistory;
     private maxHistorySize;
+    private rateLimitStore;
     constructor(config?: APIServerConfig);
     protected onInitialize(): Promise<void>;
     /**
@@ -98,6 +99,31 @@ export declare class APIServerAugmentation extends BaseAugmentation {
      * Start Service Worker (for browser)
      */
     private startServiceWorker;
+    /**
+     * Create universal handler using Web Standards (works in Node, Deno, Service Workers)
+     */
+    private createUniversalHandler;
+    /**
+     * Handle Brainy API requests using universal Request/Response
+     */
+    private handleBrainyAPI;
+    /**
+     * Handle MCP API requests
+     */
+    private handleMCPAPI;
+    /**
+     * Universal WebSocket setup (works in Node, Deno)
+     */
+    private setupUniversalWebSocket;
+    /**
+     * Service Worker messaging for WebSocket-like communication
+     */
+    private setupServiceWorkerMessaging;
+    /**
+     * Universal authentication using Web Standards
+     */
+    private authenticateRequest;
+    private checkRateLimit;
     /**
      * Shutdown the server
      */

package/dist/augmentations/apiServerAugmentation.js

@@ -29,6 +29,7 @@ export class APIServerAugmentation extends BaseAugmentation {
         this.clients = new Map();
         this.operationHistory = [];
         this.maxHistorySize = 1000;
+        this.rateLimitStore = new Map();
         this.config = {
             enabled: true,
             port: 3000,
@@ -138,7 +139,7 @@ export class APIServerAugmentation extends BaseAugmentation {
         app.post('/api/add', async (req, res) => {
             try {
                 const { content, metadata } = req.body;
-                const id = await this.context.brain.add(content, metadata);
+                const id = await this.context.brain.addNoun(content, 'Content', metadata);
                 res.json({ success: true, id });
             }
             catch (error) {
@@ -300,7 +301,7 @@ export class APIServerAugmentation extends BaseAugmentation {
                 }));
                 break;
             case 'add':
-                const id = await this.context.brain.add(msg.content, msg.metadata);
+                const id = await this.context.brain.addNoun(msg.content, 'Content', msg.metadata);
                 socket.send(JSON.stringify({
                     type: 'addResult',
                     requestId: msg.requestId,
@@ -456,17 +457,294 @@ export class APIServerAugmentation extends BaseAugmentation {
      * Start Deno server
      */
     async startDenoServer() {
-        // Deno implementation would go here
-        // Using Deno.serve() or oak framework
-        this.log('Deno server not yet implemented', 'warn');
+        try {
+            // Check if Deno.serve is available (Deno 1.35+)
+            const DenoGlobal = globalThis.Deno;
+            if (DenoGlobal && 'serve' in DenoGlobal) {
+                const handler = this.createUniversalHandler();
+                this.httpServer = DenoGlobal.serve({
+                    port: this.config.port,
+                    hostname: this.config.host || '0.0.0.0',
+                    handler: handler
+                });
+                this.log(`Deno server started on ${this.config.host || '0.0.0.0'}:${this.config.port}`);
+                // Setup WebSocket handling for Deno
+                this.setupUniversalWebSocket();
+            }
+            else {
+                throw new Error('Deno.serve not available - requires Deno 1.35+');
+            }
+        }
+        catch (error) {
+            this.log(`Failed to start Deno server: ${error.message}`, 'error');
+            throw error;
+        }
     }
     /**
      * Start Service Worker (for browser)
      */
     async startServiceWorker() {
-        // Service Worker implementation would go here
-        // Intercepts fetch() calls and handles them locally
-        this.log('Service Worker API not yet implemented', 'warn');
+        try {
+            if (typeof self !== 'undefined' && 'addEventListener' in self) {
+                // Service Worker environment - intercept fetch events
+                const handler = this.createUniversalHandler();
+                self.addEventListener('fetch', async (event) => {
+                    const url = new URL(event.request.url);
+                    // Only handle API requests
+                    if (url.pathname.startsWith('/api/') || url.pathname.startsWith('/ws') || url.pathname.startsWith('/mcp/')) {
+                        event.respondWith(handler(event.request));
+                    }
+                });
+                this.log('Service Worker API server registered for /api/, /ws, and /mcp paths');
+                // Setup message handling for WebSocket-like communication
+                this.setupServiceWorkerMessaging();
+            }
+            else if (typeof navigator !== 'undefined' && 'serviceWorker' in navigator) {
+                // Browser main thread - service worker registration should be handled by the application
+                this.log('Service Worker environment detected. Registration should be handled by your application.', 'info');
+                // Return early - the app will handle service worker registration
+                return;
+            }
+            else {
+                this.log('Service Worker environment not available', 'warn');
+                return;
+            }
+        }
+        catch (error) {
+            this.log(`Failed to start Service Worker server: ${error.message}`, 'error');
+            throw error;
+        }
+    }
+    /**
+     * Create universal handler using Web Standards (works in Node, Deno, Service Workers)
+     */
+    createUniversalHandler() {
+        return async (request) => {
+            try {
+                const url = new URL(request.url);
+                const method = request.method.toUpperCase();
+                const path = url.pathname;
+                // Add CORS headers
+                const corsOrigin = Array.isArray(this.config.cors?.origin)
+                    ? this.config.cors.origin[0]
+                    : this.config.cors?.origin || '*';
+                const headers = new Headers({
+                    'Access-Control-Allow-Origin': corsOrigin,
+                    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+                    'Content-Type': 'application/json'
+                });
+                // Handle preflight requests
+                if (method === 'OPTIONS') {
+                    return new Response(null, { status: 200, headers });
+                }
+                // Authentication
+                if (!this.authenticateRequest(request)) {
+                    return new Response(JSON.stringify({ error: 'Unauthorized' }), {
+                        status: 401,
+                        headers
+                    });
+                }
+                // Rate limiting
+                if (!this.checkRateLimit(request)) {
+                    return new Response(JSON.stringify({ error: 'Rate limit exceeded' }), {
+                        status: 429,
+                        headers
+                    });
+                }
+                // Route handling
+                if (path.startsWith('/api/brainy/')) {
+                    return this.handleBrainyAPI(request, path.replace('/api/brainy/', ''), headers);
+                }
+                else if (path.startsWith('/mcp/')) {
+                    return this.handleMCPAPI(request, path.replace('/mcp/', ''), headers);
+                }
+                else if (path === '/health') {
+                    return new Response(JSON.stringify({ status: 'ok', timestamp: Date.now() }), {
+                        status: 200,
+                        headers
+                    });
+                }
+                return new Response(JSON.stringify({ error: 'Not found' }), {
+                    status: 404,
+                    headers
+                });
+            }
+            catch (error) {
+                return new Response(JSON.stringify({
+                    error: 'Internal server error',
+                    message: error.message
+                }), {
+                    status: 500,
+                    headers: new Headers({ 'Content-Type': 'application/json' })
+                });
+            }
+        };
+    }
+    /**
+     * Handle Brainy API requests using universal Request/Response
+     */
+    async handleBrainyAPI(request, path, headers) {
+        const method = request.method.toUpperCase();
+        const body = method !== 'GET' ? await request.json().catch(() => ({})) : {};
+        try {
+            let result;
+            switch (`${method} ${path}`) {
+                case 'POST add':
+                    result = { id: await this.context.brain.add(body) };
+                    break;
+                case 'GET get':
+                    const id = new URL(request.url).searchParams.get('id');
+                    result = await this.context.brain.get(id);
+                    break;
+                case 'PUT update':
+                    await this.context.brain.update(body);
+                    result = { success: true };
+                    break;
+                case 'DELETE delete':
+                    const deleteId = new URL(request.url).searchParams.get('id');
+                    await this.context.brain.delete(deleteId);
+                    result = { success: true };
+                    break;
+                case 'POST find':
+                    result = await this.context.brain.find(body);
+                    break;
+                case 'POST relate':
+                    result = { id: await this.context.brain.relate(body) };
+                    break;
+                case 'GET insights':
+                    result = await this.context.brain.insights();
+                    break;
+                default:
+                    return new Response(JSON.stringify({ error: `Unknown endpoint: ${method} ${path}` }), {
+                        status: 404,
+                        headers
+                    });
+            }
+            return new Response(JSON.stringify(result), { status: 200, headers });
+        }
+        catch (error) {
+            return new Response(JSON.stringify({
+                error: error.message
+            }), { status: 400, headers });
+        }
+    }
+    /**
+     * Handle MCP API requests
+     */
+    async handleMCPAPI(request, path, headers) {
+        try {
+            if (!this.mcpService) {
+                return new Response(JSON.stringify({ error: 'MCP service not available' }), {
+                    status: 503,
+                    headers
+                });
+            }
+            const body = await request.json().catch(() => ({}));
+            // Convert to MCP request format
+            const mcpRequest = {
+                type: path.includes('data') ? 'data_access' : 'tool_execution',
+                ...body
+            };
+            const result = await this.mcpService.handleRequest(mcpRequest);
+            return new Response(JSON.stringify(result), { status: 200, headers });
+        }
+        catch (error) {
+            return new Response(JSON.stringify({
+                error: error.message
+            }), { status: 400, headers });
+        }
+    }
+    /**
+     * Universal WebSocket setup (works in Node, Deno)
+     */
+    setupUniversalWebSocket() {
+        // WebSocket handling varies by platform but uses same interface
+        this.log('WebSocket support enabled for real-time updates');
+    }
+    /**
+     * Service Worker messaging for WebSocket-like communication
+     */
+    setupServiceWorkerMessaging() {
+        if (typeof self !== 'undefined') {
+            self.addEventListener('message', async (event) => {
+                if (event.data.type === 'brainy-api') {
+                    try {
+                        const response = await this.handleBrainyAPI(new Request('http://localhost/api/brainy/' + event.data.endpoint, {
+                            method: event.data.method || 'POST',
+                            body: JSON.stringify(event.data.data)
+                        }), event.data.endpoint, new Headers({ 'Content-Type': 'application/json' }));
+                        const result = await response.json();
+                        event.ports[0]?.postMessage({
+                            id: event.data.id,
+                            success: response.ok,
+                            data: result
+                        });
+                    }
+                    catch (error) {
+                        event.ports[0]?.postMessage({
+                            id: event.data.id,
+                            success: false,
+                            error: error.message
+                        });
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Universal authentication using Web Standards
+     */
+    authenticateRequest(request) {
+        if (!this.config.auth?.required)
+            return true;
+        const authHeader = request.headers.get('authorization');
+        if (!authHeader)
+            return false;
+        if (this.config.auth.apiKeys?.length) {
+            const apiKey = authHeader.replace('Bearer ', '');
+            return this.config.auth.apiKeys.includes(apiKey);
+        }
+        return true;
+    }
+    checkRateLimit(request) {
+        if (!this.config.rateLimit)
+            return true;
+        // Get client identifier from headers or use a default
+        const clientId = request.headers.get('x-forwarded-for') ||
+            request.headers.get('x-real-ip') ||
+            request.headers.get('cf-connecting-ip') || // Cloudflare
+            request.headers.get('x-vercel-forwarded-for') || // Vercel
+            'unknown';
+        const now = Date.now();
+        const windowMs = this.config.rateLimit.windowMs || 60000;
+        const maxRequests = this.config.rateLimit.max || 100;
+        const windowStart = now - windowMs;
+        // Get or create request timestamps for this client
+        let timestamps = this.rateLimitStore.get(clientId) || [];
+        // Remove old timestamps outside the window
+        timestamps = timestamps.filter(t => t > windowStart);
+        // Check if limit exceeded
+        if (timestamps.length >= maxRequests) {
+            this.log(`Rate limit exceeded for client ${clientId}: ${timestamps.length}/${maxRequests} requests`, 'warn');
+            return false;
+        }
+        // Add current request timestamp
+        timestamps.push(now);
+        this.rateLimitStore.set(clientId, timestamps);
+        // Periodic cleanup of old entries to prevent memory leak
+        if (this.rateLimitStore.size > 1000) {
+            for (const [id, times] of this.rateLimitStore.entries()) {
+                const validTimes = times.filter(t => t > windowStart);
+                if (validTimes.length === 0) {
+                    this.rateLimitStore.delete(id);
+                }
+                else {
+                    this.rateLimitStore.set(id, validTimes);
+                }
+            }
+        }
+        return true;
     }
     /**
      * Shutdown the server
@@ -478,7 +756,10 @@ export class APIServerAugmentation extends BaseAugmentation {
                 try {
                     client.socket.close();
                 }
-                catch { }
+                catch (error) {
+                    // Socket already closed or errored
+                    console.debug('Error closing WebSocket:', error);
+                }
             }
         }
         this.clients.clear();

package/dist/augmentations/auditLogAugmentation.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Audit Logging Augmentation
+ * Provides comprehensive audit trail for all Brainy operations
+ */
+import { BaseAugmentation } from './brainyAugmentation.js';
+import { AugmentationManifest } from './manifest.js';
+export interface AuditLogConfig {
+    enabled?: boolean;
+    logLevel?: 'minimal' | 'standard' | 'detailed';
+    includeData?: boolean;
+    includeMetadata?: boolean;
+    retention?: number;
+    storage?: 'memory' | 'file' | 'database';
+    filePath?: string;
+    maxMemoryLogs?: number;
+}
+export interface AuditLogEntry {
+    id: string;
+    timestamp: number;
+    operation: string;
+    params: any;
+    result?: any;
+    error?: any;
+    duration: number;
+    userId?: string;
+    sessionId?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Audit Log Augmentation
+ */
+export declare class AuditLogAugmentation extends BaseAugmentation {
+    readonly name = "auditLogger";
+    readonly timing: "around";
+    readonly metadata: "readonly";
+    operations: any;
+    readonly priority = 90;
+    readonly category: "core";
+    readonly description = "Comprehensive audit logging for compliance and debugging";
+    private logs;
+    private sessionId;
+    constructor(config?: AuditLogConfig);
+    getManifest(): AugmentationManifest;
+    protected onInitialize(): Promise<void>;
+    protected onShutdown(): Promise<void>;
+    /**
+     * Execute augmentation - log operations
+     */
+    execute<T = any>(operation: string, params: any, next: () => Promise<T>): Promise<T>;
+    /**
+     * Sanitize parameters to remove sensitive data
+     */
+    private sanitizeParams;
+    /**
+     * Sanitize result data
+     */
+    private sanitizeResult;
+    /**
+     * Sanitize error information
+     */
+    private sanitizeError;
+    /**
+     * Write log entry
+     */
+    private writeLog;
+    /**
+     * Flush logs to persistent storage
+     */
+    private flushLogs;
+    /**
+     * Clean up old logs based on retention
+     */
+    private cleanupOldLogs;
+    /**
+     * Generate unique ID
+     */
+    private generateId;
+    /**
+     * Query audit logs
+     */
+    queryLogs(filter?: {
+        operation?: string;
+        startTime?: number;
+        endTime?: number;
+        sessionId?: string;
+        hasError?: boolean;
+    }): AuditLogEntry[];
+    /**
+     * Get audit statistics
+     */
+    getStats(): {
+        totalLogs: number;
+        operations: Record<string, number>;
+        averageDuration: number;
+        errorRate: number;
+    };
+    /**
+     * Export logs for analysis
+     */
+    exportLogs(): AuditLogEntry[];
+    /**
+     * Clear all logs
+     */
+    clearLogs(): void;
+}
+/**
+ * Create audit log augmentation
+ */
+export declare function createAuditLogAugmentation(config?: AuditLogConfig): AuditLogAugmentation;