@soulcraft/brainy 3.20.2 → 3.20.4

package/dist/mcp/brainyMCPBroadcast.js

@@ -1,303 +0,0 @@
-/**
- * BrainyMCPBroadcast
- *
- * Enhanced MCP service with real-time WebSocket broadcasting capabilities
- * for multi-agent coordination (Jarvis ↔ Picasso communication)
- *
- * Features:
- * - WebSocket server for real-time push notifications
- * - Subscription management for multiple Claude instances
- * - Message broadcasting to all connected agents
- * - Works both locally and with cloud deployment
- */
-import { WebSocketServer, WebSocket } from 'ws';
-import { createServer } from 'node:http';
-import { BrainyMCPService } from './brainyMCPService.js';
-import { v4 as uuidv4 } from '../universal/uuid.js';
-export class BrainyMCPBroadcast extends BrainyMCPService {
-    constructor(brainyData, options = {}) {
-        super(brainyData, options);
-        this.agents = new Map();
-        this.messageHistory = [];
-        this.maxHistorySize = 100;
-    }
-    /**
-     * Start the WebSocket broadcast server
-     * @param port Port to listen on (default: 8765)
-     * @param isCloud Whether this is a cloud deployment
-     */
-    async startBroadcastServer(port = 8765, isCloud = false) {
-        return new Promise((resolve, reject) => {
-            try {
-                // Create HTTP server
-                this.httpServer = createServer((req, res) => {
-                    // Health check endpoint
-                    if (req.url === '/health') {
-                        res.writeHead(200, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            status: 'healthy',
-                            agents: Array.from(this.agents.values()).map(a => ({
-                                id: a.id,
-                                name: a.name,
-                                role: a.role,
-                                connected: true
-                            })),
-                            uptime: process.uptime()
-                        }));
-                    }
-                    else {
-                        res.writeHead(404);
-                        res.end('Not found');
-                    }
-                });
-                // Create WebSocket server
-                this.wsServer = new WebSocketServer({
-                    server: this.httpServer,
-                    perMessageDeflate: false // Better performance
-                });
-                this.wsServer.on('connection', (socket, request) => {
-                    this.handleNewConnection(socket, request);
-                });
-                // Start listening
-                this.httpServer.listen(port, () => {
-                    console.log(`🧠 Brain Jar Broadcast Server running on ${isCloud ? 'cloud' : 'local'} port ${port}`);
-                    console.log(`📡 WebSocket: ws://localhost:${port}`);
-                    console.log(`🔍 Health: http://localhost:${port}/health`);
-                    resolve();
-                });
-                // Heartbeat to keep connections alive
-                setInterval(() => {
-                    this.agents.forEach((agent) => {
-                        if (Date.now() - agent.lastSeen > 30000) {
-                            // Remove inactive agents
-                            this.removeAgent(agent.id);
-                        }
-                        else {
-                            // Send heartbeat
-                            this.sendToAgent(agent.id, {
-                                id: uuidv4(),
-                                from: 'server',
-                                type: 'heartbeat',
-                                data: { timestamp: Date.now() },
-                                timestamp: Date.now()
-                            });
-                        }
-                    });
-                }, 15000);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Handle new WebSocket connection
-     */
-    handleNewConnection(socket, request) {
-        const agentId = uuidv4();
-        // Send welcome message
-        socket.send(JSON.stringify({
-            id: uuidv4(),
-            from: 'server',
-            type: 'notification',
-            event: 'welcome',
-            data: {
-                agentId,
-                message: 'Connected to Brain Jar Broadcast Server',
-                agents: Array.from(this.agents.values()).map(a => ({
-                    id: a.id,
-                    name: a.name,
-                    role: a.role
-                }))
-            },
-            timestamp: Date.now()
-        }));
-        // Handle messages from this agent
-        socket.on('message', (data) => {
-            try {
-                const message = JSON.parse(data.toString());
-                this.handleAgentMessage(agentId, message);
-            }
-            catch (error) {
-                console.error('Invalid message from agent:', error);
-            }
-        });
-        // Handle disconnection
-        socket.on('close', () => {
-            this.removeAgent(agentId);
-        });
-        // Handle errors
-        socket.on('error', (error) => {
-            console.error(`Agent ${agentId} error:`, error);
-        });
-        // Store temporary connection until identified
-        this.agents.set(agentId, {
-            id: agentId,
-            name: 'Unknown',
-            role: 'Unknown',
-            socket,
-            lastSeen: Date.now()
-        });
-    }
-    /**
-     * Handle message from an agent
-     */
-    handleAgentMessage(agentId, message) {
-        const agent = this.agents.get(agentId);
-        if (!agent)
-            return;
-        // Update last seen
-        agent.lastSeen = Date.now();
-        // Handle identification
-        if (message.type === 'identify') {
-            agent.name = message.name || agent.name;
-            agent.role = message.role || agent.role;
-            // Notify all agents about new member
-            this.broadcast({
-                id: uuidv4(),
-                from: 'server',
-                type: 'notification',
-                event: 'agent_joined',
-                data: {
-                    agent: {
-                        id: agent.id,
-                        name: agent.name,
-                        role: agent.role
-                    }
-                },
-                timestamp: Date.now()
-            }, agentId); // Exclude the joining agent
-            // Send recent history to new agent
-            if (this.messageHistory.length > 0) {
-                this.sendToAgent(agentId, {
-                    id: uuidv4(),
-                    from: 'server',
-                    type: 'sync',
-                    data: {
-                        history: this.messageHistory.slice(-20) // Last 20 messages
-                    },
-                    timestamp: Date.now()
-                });
-            }
-            return;
-        }
-        // Create broadcast message
-        const broadcastMsg = {
-            id: message.id || uuidv4(),
-            from: agent.name,
-            to: message.to,
-            type: message.type || 'message',
-            event: message.event,
-            data: message.data,
-            timestamp: Date.now()
-        };
-        // Store in history
-        this.addToHistory(broadcastMsg);
-        // Broadcast based on recipient
-        if (message.to) {
-            // Send to specific agent(s)
-            const recipients = Array.isArray(message.to) ? message.to : [message.to];
-            recipients.forEach((recipientName) => {
-                const recipient = Array.from(this.agents.values()).find(a => a.name === recipientName);
-                if (recipient) {
-                    this.sendToAgent(recipient.id, broadcastMsg);
-                }
-            });
-        }
-        else {
-            // Broadcast to all agents except sender
-            this.broadcast(broadcastMsg, agentId);
-        }
-    }
-    /**
-     * Broadcast message to all connected agents
-     */
-    broadcast(message, excludeId) {
-        const messageStr = JSON.stringify(message);
-        this.agents.forEach((agent) => {
-            if (agent.id !== excludeId && agent.socket.readyState === WebSocket.OPEN) {
-                agent.socket.send(messageStr);
-            }
-        });
-    }
-    /**
-     * Send message to specific agent
-     */
-    sendToAgent(agentId, message) {
-        const agent = this.agents.get(agentId);
-        if (agent && agent.socket.readyState === WebSocket.OPEN) {
-            agent.socket.send(JSON.stringify(message));
-        }
-    }
-    /**
-     * Remove agent from connected list
-     */
-    removeAgent(agentId) {
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            // Notify others about disconnection
-            this.broadcast({
-                id: uuidv4(),
-                from: 'server',
-                type: 'notification',
-                event: 'agent_left',
-                data: {
-                    agent: {
-                        id: agent.id,
-                        name: agent.name,
-                        role: agent.role
-                    }
-                },
-                timestamp: Date.now()
-            });
-            this.agents.delete(agentId);
-        }
-    }
-    /**
-     * Add message to history
-     */
-    addToHistory(message) {
-        this.messageHistory.push(message);
-        // Trim history if too large
-        if (this.messageHistory.length > this.maxHistorySize) {
-            this.messageHistory = this.messageHistory.slice(-this.maxHistorySize);
-        }
-    }
-    /**
-     * Stop the broadcast server
-     */
-    async stopBroadcastServer() {
-        // Close all agent connections
-        this.agents.forEach(agent => {
-            agent.socket.close(1000, 'Server shutting down');
-        });
-        this.agents.clear();
-        // Close WebSocket server
-        if (this.wsServer) {
-            this.wsServer.close();
-        }
-        // Close HTTP server
-        if (this.httpServer) {
-            this.httpServer.close();
-        }
-    }
-    /**
-     * Get connected agents
-     */
-    getConnectedAgents() {
-        return Array.from(this.agents.values()).map(a => ({
-            id: a.id,
-            name: a.name,
-            role: a.role
-        }));
-    }
-    /**
-     * Get message history
-     */
-    getMessageHistory() {
-        return [...this.messageHistory];
-    }
-}
-// Export for both environments
-export default BrainyMCPBroadcast;
-//# sourceMappingURL=brainyMCPBroadcast.js.map

package/dist/mcp/brainyMCPClient.d.ts

@@ -1,92 +0,0 @@
-/**
- * BrainyMCPClient
- *
- * Client for connecting Claude instances to the Brain Jar Broadcast Server
- * Utilizes Brainy for persistent memory and vector search capabilities
- */
-interface ClientOptions {
-    name: string;
-    role: string;
-    serverUrl?: string;
-    autoReconnect?: boolean;
-    useBrainyMemory?: boolean;
-}
-interface Message {
-    id: string;
-    from: string;
-    to?: string | string[];
-    type: 'message' | 'notification' | 'sync' | 'heartbeat' | 'identify';
-    event?: string;
-    data: any;
-    timestamp: number;
-}
-export declare class BrainyMCPClient {
-    private socket?;
-    private options;
-    private brainy?;
-    private messageHandlers;
-    private reconnectTimeout?;
-    private isConnected;
-    constructor(options: ClientOptions);
-    /**
-     * Initialize Brainy for persistent memory
-     */
-    private initBrainy;
-    /**
-     * Connect to the broadcast server
-     */
-    connect(): Promise<void>;
-    /**
-     * Handle incoming message
-     */
-    private handleMessage;
-    /**
-     * Send a message
-     */
-    send(message: Partial<Message>): void;
-    /**
-     * Send a message to specific agent(s)
-     */
-    sendTo(recipient: string | string[], data: any): void;
-    /**
-     * Broadcast to all agents
-     */
-    broadcast(data: any): void;
-    /**
-     * Register a message handler
-     */
-    on(type: string, handler: (message: Message) => void): void;
-    /**
-     * Remove a message handler
-     */
-    off(type: string): void;
-    /**
-     * Search historical messages using Brainy's vector search
-     */
-    searchMemory(query: string, limit?: number): Promise<any[]>;
-    /**
-     * Get recent messages from Brainy memory
-     */
-    getRecentMessages(limit?: number): Promise<any[]>;
-    /**
-     * Schedule reconnection attempt
-     */
-    private scheduleReconnect;
-    /**
-     * Disconnect from server
-     */
-    disconnect(): void;
-    /**
-     * Check if connected
-     */
-    getIsConnected(): boolean;
-    /**
-     * Get agent info
-     */
-    getAgentInfo(): {
-        name: string;
-        role: string;
-        connected: boolean;
-    };
-}
-export default BrainyMCPClient;

package/dist/mcp/brainyMCPClient.js

@@ -1,258 +0,0 @@
-/**
- * BrainyMCPClient
- *
- * Client for connecting Claude instances to the Brain Jar Broadcast Server
- * Utilizes Brainy for persistent memory and vector search capabilities
- */
-import WebSocket from 'ws';
-import { Brainy } from '../brainy.js';
-import { v4 as uuidv4 } from '../universal/uuid.js';
-export class BrainyMCPClient {
-    constructor(options) {
-        this.messageHandlers = new Map();
-        this.isConnected = false;
-        this.options = {
-            serverUrl: 'ws://localhost:8765',
-            autoReconnect: true,
-            useBrainyMemory: true,
-            ...options
-        };
-    }
-    /**
-     * Initialize Brainy for persistent memory
-     */
-    async initBrainy() {
-        if (this.options.useBrainyMemory && !this.brainy) {
-            this.brainy = new Brainy({
-                storage: {
-                    requestPersistentStorage: true
-                }
-            });
-            await this.brainy.init();
-            console.log(`🧠 Brainy memory initialized for ${this.options.name}`);
-        }
-    }
-    /**
-     * Connect to the broadcast server
-     */
-    async connect() {
-        // Initialize Brainy first
-        await this.initBrainy();
-        return new Promise((resolve, reject) => {
-            try {
-                this.socket = new WebSocket(this.options.serverUrl);
-                this.socket.on('open', () => {
-                    console.log(`✅ ${this.options.name} connected to Brain Jar Broadcast`);
-                    this.isConnected = true;
-                    // Identify ourselves
-                    this.send({
-                        type: 'identify',
-                        data: {
-                            name: this.options.name,
-                            role: this.options.role
-                        }
-                    });
-                    resolve();
-                });
-                this.socket.on('message', async (data) => {
-                    try {
-                        const message = JSON.parse(data.toString());
-                        await this.handleMessage(message);
-                    }
-                    catch (error) {
-                        console.error('Error parsing message:', error);
-                    }
-                });
-                this.socket.on('close', () => {
-                    console.log(`❌ ${this.options.name} disconnected from Brain Jar`);
-                    this.isConnected = false;
-                    if (this.options.autoReconnect) {
-                        this.scheduleReconnect();
-                    }
-                });
-                this.socket.on('error', (error) => {
-                    console.error(`Connection error for ${this.options.name}:`, error);
-                    reject(error);
-                });
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    /**
-     * Handle incoming message
-     */
-    async handleMessage(message) {
-        // Store in Brainy for persistent memory
-        if (this.brainy && message.type === 'message') {
-            try {
-                await this.brainy.add({
-                    text: `${message.from}: ${JSON.stringify(message.data)}`,
-                    metadata: {
-                        messageId: message.id,
-                        from: message.from,
-                        to: message.to,
-                        timestamp: message.timestamp,
-                        type: message.type,
-                        event: message.event,
-                        category: 'Message'
-                    }
-                });
-            }
-            catch (error) {
-                console.error('Error storing message in Brainy:', error);
-            }
-        }
-        // Handle sync messages (receive history)
-        if (message.type === 'sync' && message.data.history) {
-            console.log(`📜 ${this.options.name} received ${message.data.history.length} historical messages`);
-            // Store history in Brainy
-            if (this.brainy) {
-                for (const histMsg of message.data.history) {
-                    await this.brainy.add({
-                        text: `${histMsg.from}: ${JSON.stringify(histMsg.data)}`,
-                        metadata: {
-                            ...histMsg,
-                            category: 'Message'
-                        }
-                    });
-                }
-            }
-        }
-        // Call registered handlers
-        const handler = this.messageHandlers.get(message.type);
-        if (handler) {
-            handler(message);
-        }
-        // Call universal handler
-        const universalHandler = this.messageHandlers.get('*');
-        if (universalHandler) {
-            universalHandler(message);
-        }
-    }
-    /**
-     * Send a message
-     */
-    send(message) {
-        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
-            console.error(`${this.options.name} is not connected`);
-            return;
-        }
-        const fullMessage = {
-            id: message.id || uuidv4(),
-            from: this.options.name,
-            type: message.type || 'message',
-            data: message.data || {},
-            timestamp: Date.now(),
-            ...message
-        };
-        this.socket.send(JSON.stringify(fullMessage));
-    }
-    /**
-     * Send a message to specific agent(s)
-     */
-    sendTo(recipient, data) {
-        this.send({
-            to: recipient,
-            type: 'message',
-            data
-        });
-    }
-    /**
-     * Broadcast to all agents
-     */
-    broadcast(data) {
-        this.send({
-            type: 'message',
-            data
-        });
-    }
-    /**
-     * Register a message handler
-     */
-    on(type, handler) {
-        this.messageHandlers.set(type, handler);
-    }
-    /**
-     * Remove a message handler
-     */
-    off(type) {
-        this.messageHandlers.delete(type);
-    }
-    /**
-     * Search historical messages using Brainy's vector search
-     */
-    async searchMemory(query, limit = 10) {
-        if (!this.brainy) {
-            console.warn('Brainy memory not initialized');
-            return [];
-        }
-        const results = await this.brainy.search(query, limit);
-        return results.map(r => ({
-            ...r.metadata,
-            relevance: r.score
-        }));
-    }
-    /**
-     * Get recent messages from Brainy memory
-     */
-    async getRecentMessages(limit = 20) {
-        if (!this.brainy) {
-            console.warn('Brainy memory not initialized');
-            return [];
-        }
-        // Search for recent activity
-        const results = await this.brainy.search('recent messages communication', limit);
-        return results
-            .map(r => r.metadata)
-            .sort((a, b) => b.timestamp - a.timestamp);
-    }
-    /**
-     * Schedule reconnection attempt
-     */
-    scheduleReconnect() {
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-        }
-        this.reconnectTimeout = setTimeout(() => {
-            console.log(`🔄 ${this.options.name} attempting to reconnect...`);
-            this.connect().catch(error => {
-                console.error('Reconnection failed:', error);
-                this.scheduleReconnect();
-            });
-        }, 5000);
-    }
-    /**
-     * Disconnect from server
-     */
-    disconnect() {
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-        }
-        if (this.socket) {
-            this.socket.close(1000, 'Client disconnecting');
-            this.socket = undefined;
-        }
-        this.isConnected = false;
-    }
-    /**
-     * Check if connected
-     */
-    getIsConnected() {
-        return this.isConnected;
-    }
-    /**
-     * Get agent info
-     */
-    getAgentInfo() {
-        return {
-            name: this.options.name,
-            role: this.options.role,
-            connected: this.isConnected
-        };
-    }
-}
-// Export for both environments
-export default BrainyMCPClient;
-//# sourceMappingURL=brainyMCPClient.js.map

package/dist/scripts/precomputePatternEmbeddings.d.ts

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-/**
- * 🧠 Pre-compute Pattern Embeddings Script
- *
- * This script pre-computes embeddings for all patterns and saves them to disk.
- * Run this once after adding new patterns to avoid runtime embedding costs.
- *
- * How it works:
- * 1. Load all patterns from library.json
- * 2. Use Brainy's embedding model to encode each pattern's examples
- * 3. Average the example embeddings to get a robust pattern representation
- * 4. Save embeddings to patterns/embeddings.bin for instant loading
- *
- * Benefits:
- * - Pattern matching becomes pure math (cosine similarity)
- * - No embedding model calls during query processing
- * - Patterns load instantly with pre-computed vectors
- */
-export {};