Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

πŸ”– Checkpoint: Edit /workspaces/claude-code-flow/src/ui/console/js/real-time-dashboard.js

rUve6f1b8b68521
diff --git a/.claude/checkpoints/1756476093.json b/.claude/checkpoints/1756476093.json
new file mode 100644
index 0000000000..ac41229821
--- /dev/null
+++ b/.claude/checkpoints/1756476093.json
@@ -0,0 +1 @@
+{"branch": "checkpoint/pre-edit-20250829-140133", "file": "/workspaces/claude-code-flow/src/ui/console/js/swarm-visualizer.js", "timestamp": "2025-08-29T14:01:33Z", "type": "pre-edit", "original_branch": "alpha101"}
diff --git a/.claude/checkpoints/1756476098.json b/.claude/checkpoints/1756476098.json
new file mode 100644
index 0000000000..4a38fc1f27
--- /dev/null
+++ b/.claude/checkpoints/1756476098.json
@@ -0,0 +1 @@
+{"tag": "checkpoint-20250829-140138", "file": "/workspaces/claude-code-flow/src/ui/console/js/swarm-visualizer.js", "timestamp": "2025-08-29T14:01:38Z", "type": "post-edit", "branch": "alpha101", "diff_summary": " .claude-flow/metrics/performance.json | 2 +- .claude-flow/metrics/task-metrics.json | 8 +- claude-flow-wiki | 0 src/ui/console/js/swarm-visualizer.js | 879 +++++++++++++++++++++++++++++++++ 4 files changed, 884 insertions(+), 5 deletions(-) "}
diff --git a/src/ui/console/js/real-time-dashboard.js b/src/ui/console/js/real-time-dashboard.js
new file mode 100644
index 0000000000..014747d350
--- /dev/null
+++ b/src/ui/console/js/real-time-dashboard.js
@@ -0,0 +1,715 @@
+/**
+ * RealTimeDashboard - Enhanced real-time monitoring dashboard for Claude Flow swarms
+ * Integrates multiple visualization components with live data updates
+ */
+
+import { SwarmVisualizer } from './swarm-visualizer.js';
+
+export class RealTimeDashboard {
+ constructor(container, componentLibrary) {
+ this.container = container;
+ this.components = componentLibrary;
+ this.swarmVisualizer = null;
+ this.isActive = false;
+ this.updateInterval = null;
+ this.websocket = null;
+ this.metrics = {
+ history: [],
+ current: null
+ };
+
+ this.init();
+ }
+
+ /**
+ * Initialize dashboard
+ */
+ init() {
+ this.createDashboardLayout();
+ this.setupWebSocket();
+ this.startMetricsCollection();
+ console.log('πŸ“Š Real-time Dashboard initialized');
+ }
+
+ /**
+ * Create dashboard layout
+ */
+ createDashboardLayout() {
+ // Main dashboard container
+ const dashboard = document.createElement('div');
+ dashboard.className = 'claude-realtime-dashboard';
+ dashboard.style.cssText = `
+ display: grid;
+ grid-template-columns: 1fr 1fr;
+ grid-template-rows: auto 1fr auto;
+ gap: 16px;
+ height: 100vh;
+ padding: 16px;
+ background: #0a0a0a;
+ color: white;
+ `;
+
+ // Header with title and controls
+ const header = this.createDashboardHeader();
+ dashboard.appendChild(header);
+
+ // Main content area
+ const content = document.createElement('div');
+ content.style.cssText = `
+ grid-column: 1 / -1;
+ display: grid;
+ grid-template-columns: 2fr 1fr;
+ gap: 16px;
+ overflow: hidden;
+ `;
+
+ // Left panel - Swarm Visualizer
+ const leftPanel = document.createElement('div');
+ leftPanel.className = 'dashboard-left-panel';
+ this.swarmVisualizer = new SwarmVisualizer(leftPanel, this.components);
+
+ // Right panel - Metrics and controls
+ const rightPanel = this.createRightPanel();
+
+ content.appendChild(leftPanel);
+ content.appendChild(rightPanel);
+ dashboard.appendChild(content);
+
+ // Footer with status information
+ const footer = this.createDashboardFooter();
+ dashboard.appendChild(footer);
+
+ this.container.appendChild(dashboard);
+
+ this.elements = {
+ dashboard,
+ header,
+ content,
+ leftPanel,
+ rightPanel,
+ footer
+ };
+ }
+
+ /**
+ * Create dashboard header
+ */
+ createDashboardHeader() {
+ const header = document.createElement('div');
+ header.style.cssText = `
+ grid-column: 1 / -1;
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ padding: 16px;
+ background: #1a1a1a;
+ border: 1px solid #444;
+ border-radius: 8px;
+ `;
+
+ // Title and status
+ const titleSection = document.createElement('div');
+ titleSection.innerHTML = `
+ <h1 style="margin: 0; color: #00d4ff; font-size: 24px;">
+ 🌊 Claude Flow Real-Time Dashboard
+ </h1>
+ <p style="margin: 4px 0 0 0; color: #888; font-size: 14px;">
+ Live swarm monitoring and performance analytics
+ </p>
+ `;
+
+ // Control buttons
+ const controls = document.createElement('div');
+ controls.style.display = 'flex';
+ controls.style.gap = '12px';
+
+ const startBtn = this.components.createActionButton({
+ type: 'primary',
+ text: 'Start All',
+ icon: '▢️',
+ onclick: () => this.startAllMonitoring()
+ });
+
+ const stopBtn = this.components.createActionButton({
+ type: 'secondary',
+ text: 'Stop All',
+ icon: '⏹️',
+ onclick: () => this.stopAllMonitoring()
+ });
+
+ const exportBtn = this.components.createActionButton({
+ type: 'secondary',
+ text: 'Export Data',
+ icon: 'πŸ’Ύ',
+ onclick: () => this.exportDashboardData()
+ });
+
+ controls.appendChild(startBtn.element);
+ controls.appendChild(stopBtn.element);
+ controls.appendChild(exportBtn.element);
+
+ header.appendChild(titleSection);
+ header.appendChild(controls);
+
+ this.headerElements = {
+ startBtn,
+ stopBtn,
+ exportBtn
+ };
+
+ return header;
+ }
+
+ /**
+ * Create right panel with metrics and controls
+ */
+ createRightPanel() {
+ const panel = document.createElement('div');
+ panel.style.cssText = `
+ display: flex;
+ flex-direction: column;
+ gap: 16px;
+ overflow-y: auto;
+ `;
+
+ // Performance metrics chart
+ const metricsChart = this.createMetricsChart();
+ panel.appendChild(metricsChart);
+
+ // System health indicators
+ const healthPanel = this.createHealthPanel();
+ panel.appendChild(healthPanel);
+
+ // Memory usage chart
+ const memoryChart = this.createMemoryChart();
+ panel.appendChild(memoryChart);
+
+ // Task queue status
+ const queueStatus = this.createQueueStatus();
+ panel.appendChild(queueStatus);
+
+ // Recent activities log
+ const activityLog = this.createActivityLog();
+ panel.appendChild(activityLog);
+
+ return panel;
+ }
+
+ /**
+ * Create performance metrics chart
+ */
+ createMetricsChart() {
+ const metricsChart = this.components.createMetricsChart({
+ title: 'Performance Metrics',
+ width: 350,
+ height: 200,
+ type: 'line'
+ });
+
+ // Sample data
+ this.updateMetricsChart(metricsChart);
+
+ this.metricsChart = metricsChart;
+ return metricsChart.element;
+ }
+
+ /**
+ * Create system health panel
+ */
+ createHealthPanel() {
+ const panel = this.components.createInfoPanel({
+ title: 'πŸ₯ System Health'
+ });
+
+ const healthMetrics = [
+ { name: 'CPU Usage', value: '45%', status: 'good' },
+ { name: 'Memory Usage', value: '2.1GB', status: 'good' },
+ { name: 'Network I/O', value: '120 Mbps', status: 'good' },
+ { name: 'Disk Usage', value: '67%', status: 'warning' },
+ { name: 'Response Time', value: '234ms', status: 'good' }
+ ];
+
+ const healthHTML = healthMetrics.map(metric => `
+ <div style="display: flex; justify-content: space-between; align-items: center; margin: 8px 0;">
+ <span>${metric.name}:</span>
+ <span class="health-metric health-${metric.status}" style="
+ padding: 4px 8px;
+ border-radius: 4px;
+ font-weight: bold;
+ ${metric.status === 'good' ? 'background: #22c55e; color: white;' :
+ metric.status === 'warning' ? 'background: #f59e0b; color: white;' :
+ 'background: #ef4444; color: white;'}
+ ">${metric.value}</span>
+ </div>
+ `).join('');
+
+ panel.setContent(healthHTML);
+ this.healthPanel = panel;
+ return panel.element;
+ }
+
+ /**
+ * Create memory usage chart
+ */
+ createMemoryChart() {
+ const memoryChart = this.components.createMetricsChart({
+ title: 'Memory Usage Over Time',
+ width: 350,
+ height: 150,
+ type: 'line'
+ });
+
+ this.updateMemoryChart(memoryChart);
+ this.memoryChart = memoryChart;
+ return memoryChart.element;
+ }
+
+ /**
+ * Create task queue status
+ */
+ createQueueStatus() {
+ const panel = this.components.createInfoPanel({
+ title: 'πŸ“‹ Task Queue Status'
+ });
+
+ const queueData = {
+ pending: Math.floor(Math.random() * 20),
+ processing: Math.floor(Math.random() * 8),
+ completed: Math.floor(Math.random() * 150) + 50,
+ failed: Math.floor(Math.random() * 5)
+ };
+
+ const queueHTML = `
+ <div class="queue-stats" style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px;">
+ <div class="queue-stat">
+ <div style="font-size: 24px; font-weight: bold; color: #f59e0b;">${queueData.pending}</div>
+ <div style="color: #888; font-size: 12px;">Pending</div>
+ </div>
+ <div class="queue-stat">
+ <div style="font-size: 24px; font-weight: bold; color: #00d4ff;">${queueData.processing}</div>
+ <div style="color: #888; font-size: 12px;">Processing</div>
+ </div>
+ <div class="queue-stat">
+ <div style="font-size: 24px; font-weight: bold; color: #22c55e;">${queueData.completed}</div>
+ <div style="color: #888; font-size: 12px;">Completed</div>
+ </div>
+ <div class="queue-stat">
+ <div style="font-size: 24px; font-weight: bold; color: #ef4444;">${queueData.failed}</div>
+ <div style="color: #888; font-size: 12px;">Failed</div>
+ </div>
+ </div>
+ `;
+
+ panel.setContent(queueHTML);
+ this.queuePanel = panel;
+ return panel.element;
+ }
+
+ /**
+ * Create activity log
+ */
+ createActivityLog() {
+ const panel = this.components.createInfoPanel({
+ title: 'πŸ“ Recent Activity'
+ });
+
+ const activities = [
+ { time: '14:23:15', type: 'info', message: 'Agent coder_01 completed task #127' },
+ { time: '14:22:58', type: 'success', message: 'Swarm topology optimized (+12% efficiency)' },
+ { time: '14:22:45', type: 'warning', message: 'Agent analyzer_03 high memory usage (89%)' },
+ { time: '14:22:30', type: 'info', message: 'New task assigned to researcher_02' },
+ { time: '14:22:12', type: 'error', message: 'Connection timeout to agent reviewer_01' }
+ ];
+
+ const activityHTML = activities.map(activity => `
+ <div class="activity-item" style="
+ display: flex;
+ gap: 8px;
+ margin: 8px 0;
+ padding: 8px;
+ background: #2a2a2a;
+ border-radius: 4px;
+ border-left: 3px solid ${
+ activity.type === 'success' ? '#22c55e' :
+ activity.type === 'warning' ? '#f59e0b' :
+ activity.type === 'error' ? '#ef4444' : '#00d4ff'
+ };
+ ">
+ <span style="color: #888; font-size: 12px; min-width: 60px;">${activity.time}</span>
+ <span style="font-size: 14px;">${activity.message}</span>
+ </div>
+ `).join('');
+
+ panel.setContent(`<div style="max-height: 200px; overflow-y: auto;">${activityHTML}</div>`);
+ this.activityPanel = panel;
+ return panel.element;
+ }
+
+ /**
+ * Create dashboard footer
+ */
+ createDashboardFooter() {
+ const footer = document.createElement('div');
+ footer.style.cssText = `
+ grid-column: 1 / -1;
+ display: flex;
+ justify-content: space-between;
+ align-items: center;
+ padding: 12px 16px;
+ background: #1a1a1a;
+ border: 1px solid #444;
+ border-radius: 8px;
+ font-size: 12px;
+ color: #888;
+ `;
+
+ const leftStatus = document.createElement('div');
+ leftStatus.innerHTML = `
+ Status: <span id="dashboard-status" style="color: #22c55e;">●</span> Active |
+ Uptime: <span id="dashboard-uptime">00:00:00</span> |
+ Last Update: <span id="dashboard-last-update">Never</span>
+ `;
+
+ const rightStatus = document.createElement('div');
+ rightStatus.innerHTML = `
+ Total Messages: <span id="dashboard-messages">0</span> |
+ Data Points: <span id="dashboard-data-points">0</span> |
+ Version: Claude Flow v2.0.0
+ `;
+
+ footer.appendChild(leftStatus);
+ footer.appendChild(rightStatus);
+
+ this.footerElements = {
+ status: leftStatus.querySelector('#dashboard-status'),
+ uptime: leftStatus.querySelector('#dashboard-uptime'),
+ lastUpdate: leftStatus.querySelector('#dashboard-last-update'),
+ messages: rightStatus.querySelector('#dashboard-messages'),
+ dataPoints: rightStatus.querySelector('#dashboard-data-points')
+ };
+
+ return footer;
+ }
+
+ /**
+ * Setup WebSocket connection for real-time updates
+ */
+ setupWebSocket() {
+ try {
+ const wsUrl = 'ws://localhost:3000/dashboard';
+ this.websocket = new WebSocket(wsUrl);
+
+ this.websocket.onopen = () => {
+ console.log('πŸ“‘ Dashboard WebSocket connected');
+ this.updateConnectionStatus(true);
+ };
+
+ this.websocket.onmessage = (event) => {
+ try {
+ const data = JSON.parse(event.data);
+ this.handleWebSocketMessage(data);
+ } catch (error) {
+ console.warn('Failed to parse WebSocket message:', error);
+ }
+ };
+
+ this.websocket.onclose = () => {
+ console.log('πŸ“‘ Dashboard WebSocket disconnected');
+ this.updateConnectionStatus(false);
+ // Attempt reconnection after 5 seconds
+ setTimeout(() => this.setupWebSocket(), 5000);
+ };
+
+ this.websocket.onerror = (error) => {
+ console.error('πŸ“‘ Dashboard WebSocket error:', error);
+ };
+
+ } catch (error) {
+ console.warn('WebSocket not available, using polling fallback');
+ this.startPollingFallback();
+ }
+ }
+
+ /**
+ * Handle WebSocket messages
+ */
+ handleWebSocketMessage(data) {
+ switch (data.type) {
+ case 'swarm_update':
+ // Forward to swarm visualizer
+ if (this.swarmVisualizer) {
+ this.swarmVisualizer.swarmData = data.payload;
+ this.swarmVisualizer.processSwarmData();
+ this.swarmVisualizer.updateStats();
+ }
+ break;
+
+ case 'metrics_update':
+ this.updateMetricsFromData(data.payload);
+ break;
+
+ case 'health_update':
+ this.updateHealthStatus(data.payload);
+ break;
+
+ case 'activity_log':
+ this.addActivityLog(data.payload);
+ break;
+
+ default:
+ console.log('Unknown WebSocket message type:', data.type);
+ }
+
+ this.updateLastUpdateTime();
+ }
+
+ /**
+ * Start polling fallback for when WebSocket isn't available
+ */
+ startPollingFallback() {
+ this.updateInterval = setInterval(() => {
+ this.fetchDashboardData();
+ }, 2000);
+ }
+
+ /**
+ * Fetch dashboard data via HTTP
+ */
+ async fetchDashboardData() {
+ try {
+ const response = await fetch('/api/claude-flow/dashboard/data');
+ if (response.ok) {
+ const data = await response.json();
+ this.handleDashboardData(data);
+ }
+ } catch (error) {
+ console.warn('Failed to fetch dashboard data:', error);
+ // Generate mock data for demo
+ this.handleDashboardData(this.generateMockDashboardData());
+ }
+ }
+
+ /**
+ * Generate mock dashboard data
+ */
+ generateMockDashboardData() {
+ return {
+ swarm: {
+ agents: 6,
+ active: 4,
+ busy: 2,
+ idle: 2,
+ errors: 0
+ },
+ metrics: {
+ cpuUsage: Math.random() * 30 + 20,
+ memoryUsage: Math.random() * 40 + 40,
+ throughput: Math.random() * 50 + 25,
+ latency: Math.random() * 200 + 100
+ },
+ health: {
+ overall: 'good',
+ services: ['swarm', 'memory', 'neural'].map(service => ({
+ name: service,
+ status: Math.random() > 0.8 ? 'warning' : 'good'
+ }))
+ }
+ };
+ }
+
+ /**
+ * Update metrics charts with new data
+ */
+ updateMetricsFromData(data) {
+ // Add to history
+ this.metrics.history.push({
+ timestamp: Date.now(),
+ ...data
+ });
+
+ // Keep only last 50 data points
+ if (this.metrics.history.length > 50) {
+ this.metrics.history.shift();
+ }
+
+ this.metrics.current = data;
+ this.updateMetricsChart(this.metricsChart);
+ this.updateMemoryChart(this.memoryChart);
+ }
+
+ /**
+ * Update metrics chart
+ */
+ updateMetricsChart(chart) {
+ if (!chart || !this.metrics.history.length) return;
+
+ const data = this.metrics.history.map((point, index) => ({
+ x: index,
+ value: point.throughput || Math.random() * 100
+ }));
+
+ chart.updateData(data);
+ }
+
+ /**
+ * Update memory chart
+ */
+ updateMemoryChart(chart) {
+ if (!chart || !this.metrics.history.length) return;
+
+ const data = this.metrics.history.map((point, index) => ({
+ x: index,
+ value: point.memoryUsage || Math.random() * 100
+ }));
+
+ chart.updateData(data);
+ }
+
+ /**
+ * Start all monitoring systems
+ */
+ startAllMonitoring() {
+ this.isActive = true;
+
+ // Start swarm visualizer
+ if (this.swarmVisualizer) {
+ this.swarmVisualizer.startMonitoring();
+ }
+
+ // Start metrics collection
+ this.startMetricsCollection();
+
+ // Update UI state
+ this.headerElements.startBtn.setDisabled(true);
+ this.headerElements.stopBtn.setDisabled(false);
+ this.updateConnectionStatus(true);
+
+ console.log('πŸš€ All dashboard monitoring started');
+ }
+
+ /**
+ * Stop all monitoring systems
+ */
+ stopAllMonitoring() {
+ this.isActive = false;
+
+ // Stop swarm visualizer
+ if (this.swarmVisualizer) {
+ this.swarmVisualizer.stopMonitoring();
+ }
+
+ // Stop metrics collection
+ if (this.updateInterval) {
+ clearInterval(this.updateInterval);
+ this.updateInterval = null;
+ }
+
+ // Update UI state
+ this.headerElements.startBtn.setDisabled(false);
+ this.headerElements.stopBtn.setDisabled(true);
+ this.updateConnectionStatus(false);
+
+ console.log('⏹️ All dashboard monitoring stopped');
+ }
+
+ /**
+ * Start metrics collection
+ */
+ startMetricsCollection() {
+ if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) {
+ this.startPollingFallback();
+ }
+ }
+
+ /**
+ * Update connection status
+ */
+ updateConnectionStatus(connected) {
+ if (this.footerElements.status) {
+ this.footerElements.status.style.color = connected ? '#22c55e' : '#ef4444';
+ this.footerElements.status.textContent = connected ? '●' : '●';
+ }
+ }
+
+ /**
+ * Update last update time
+ */
+ updateLastUpdateTime() {
+ if (this.footerElements.lastUpdate) {
+ this.footerElements.lastUpdate.textContent = new Date().toLocaleTimeString();
+ }
+ }
+
+ /**
+ * Export dashboard data
+ */
+ exportDashboardData() {
+ const exportData = {
+ timestamp: Date.now(),
+ metrics: this.metrics,
+ swarmData: this.swarmVisualizer?.swarmData,
+ version: 'Claude Flow v2.0.0'
+ };
+
+ const blob = new Blob([JSON.stringify(exportData, null, 2)], {
+ type: 'application/json'
+ });
+
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = `claude-flow-dashboard-${Date.now()}.json`;
+ document.body.appendChild(a);
+ a.click();
+ document.body.removeChild(a);
+ URL.revokeObjectURL(url);
+
+ console.log('πŸ’Ύ Dashboard data exported');
+ }
+
+ /**
+ * Store progress to swarm memory
+ */
+ async storeProgressToMemory() {
+ const progressData = {
+ dashboardActive: this.isActive,
+ metricsCount: this.metrics.history.length,
+ swarmVisualizerActive: this.swarmVisualizer?.isActive || false,
+ lastUpdate: Date.now(),
+ components: {
+ swarmVisualizer: 'active',
+ metricsChart: 'active',
+ healthPanel: 'active',
+ activityLog: 'active'
+ }
+ };
+
+ try {
+ // This would normally call the memory API
+ console.log('πŸ“Š Storing dashboard progress to memory:', progressData);
+ } catch (error) {
+ console.warn('Failed to store progress to memory:', error);
+ }
+ }
+
+ /**
+ * Cleanup resources
+ */
+ destroy() {
+ this.stopAllMonitoring();
+
+ if (this.websocket) {
+ this.websocket.close();
+ }
+
+ if (this.swarmVisualizer) {
+ this.swarmVisualizer.destroy();
+ }
+
+ if (this.container) {
+ this.container.innerHTML = '';
+ }
+ }
+}
+
+export default RealTimeDashboard;
\ No newline at end of file