Initial commit: Complete Hive distributed AI orchestration platform

This comprehensive implementation includes:
- FastAPI backend with MCP server integration
- React/TypeScript frontend with Vite
- PostgreSQL database with Redis caching
- Grafana/Prometheus monitoring stack
- Docker Compose orchestration
- Full MCP protocol support for Claude Code integration

Features:
- Agent discovery and management across network
- Visual workflow editor and execution engine
- Real-time task coordination and monitoring
- Multi-model support with specialized agents
- Distributed development task allocation

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

mcp-server/dist/hive-client.js

@@ -0,0 +1,123 @@
+/**
+ * Hive Client
+ *
+ * Handles communication with the Hive backend API
+ */
+import axios from 'axios';
+import WebSocket from 'ws';
+export class HiveClient {
+    api;
+    config;
+    wsConnection;
+    constructor(config) {
+        this.config = {
+            baseUrl: process.env.HIVE_API_URL || 'http://localhost:8087',
+            wsUrl: process.env.HIVE_WS_URL || 'ws://localhost:8087',
+            timeout: 30000,
+            ...config,
+        };
+        this.api = axios.create({
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    async testConnection() {
+        try {
+            const response = await this.api.get('/health');
+            return response.data.status === 'healthy';
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Hive: ${error}`);
+        }
+    }
+    // Agent Management
+    async getAgents() {
+        const response = await this.api.get('/api/agents');
+        return response.data.agents || [];
+    }
+    async registerAgent(agentData) {
+        const response = await this.api.post('/api/agents', agentData);
+        return response.data;
+    }
+    // Task Management
+    async createTask(taskData) {
+        const response = await this.api.post('/api/tasks', taskData);
+        return response.data;
+    }
+    async getTask(taskId) {
+        const response = await this.api.get(`/api/tasks/${taskId}`);
+        return response.data;
+    }
+    async getTasks(filters) {
+        const params = new URLSearchParams();
+        if (filters?.status)
+            params.append('status', filters.status);
+        if (filters?.agent)
+            params.append('agent', filters.agent);
+        if (filters?.limit)
+            params.append('limit', filters.limit.toString());
+        const response = await this.api.get(`/api/tasks?${params}`);
+        return response.data.tasks || [];
+    }
+    // Workflow Management
+    async getWorkflows() {
+        const response = await this.api.get('/api/workflows');
+        return response.data.workflows || [];
+    }
+    async createWorkflow(workflowData) {
+        const response = await this.api.post('/api/workflows', workflowData);
+        return response.data;
+    }
+    async executeWorkflow(workflowId, inputs) {
+        const response = await this.api.post(`/api/workflows/${workflowId}/execute`, { inputs });
+        return response.data;
+    }
+    // Monitoring and Status
+    async getClusterStatus() {
+        const response = await this.api.get('/api/status');
+        return response.data;
+    }
+    async getMetrics() {
+        const response = await this.api.get('/api/metrics');
+        return response.data;
+    }
+    async getExecutions(workflowId) {
+        const url = workflowId ? `/api/executions?workflow_id=${workflowId}` : '/api/executions';
+        const response = await this.api.get(url);
+        return response.data.executions || [];
+    }
+    // Real-time Updates via WebSocket
+    async connectWebSocket(topic = 'general') {
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`${this.config.wsUrl}/ws/${topic}`);
+            ws.on('open', () => {
+                console.log(`🔗 Connected to Hive WebSocket (${topic})`);
+                this.wsConnection = ws;
+                resolve(ws);
+            });
+            ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+                reject(error);
+            });
+            ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    console.log('📨 Hive update:', message);
+                }
+                catch (error) {
+                    console.error('Failed to parse WebSocket message:', error);
+                }
+            });
+        });
+    }
+    async disconnect() {
+        if (this.wsConnection) {
+            this.wsConnection.close();
+            this.wsConnection = undefined;
+        }
+    }
+}
+//# sourceMappingURL=hive-client.js.map