Code-Mesh TUI 🖥️✨

Interactive Terminal User Interface for the Code-Mesh distributed swarm intelligence system.

Code-Mesh TUI provides a beautiful, feature-rich terminal interface to visualize, monitor, and control your Code-Mesh swarms in real-time. Experience the power of distributed computing through an intuitive, responsive interface.

🌟 Features

🎨 Beautiful Interface

• Modern Design: Clean, intuitive interface with customizable themes
• Real-time Updates: Live monitoring with smooth animations
• Responsive Layout: Adapts to any terminal size
• Syntax Highlighting: Code display with language-aware highlighting

📊 Visual Monitoring

• Swarm Topology Visualization: Interactive network graphs of agent relationships
• Performance Dashboards: Real-time metrics with charts and graphs
• Agent Status Display: Live status updates for all active agents
• Task Progress Tracking: Visual progress bars and completion indicators

🎮 Interactive Controls

• Command Palette: Quick access to all functions with fuzzy search
• Keyboard Shortcuts: Efficient navigation and control
• Mouse Support: Click and scroll support where available
• Multi-panel Layout: Split views for monitoring multiple aspects simultaneously

🧠 Neural Intelligence Visualization

• Neural Network Display: Visual representation of agent neural networks
• Learning Progress: Real-time learning metrics and pattern recognition
• Cognitive Pattern Visualization: See how different thinking patterns work
• Cross-Agent Communication: Visualize message passing between agents

🚀 Installation

From Crates.io

cargo install code-mesh-tui

From Source

git clone https://github.com/ruvnet/code-mesh
cd code-mesh
cargo install --path crates/code-mesh-tui

As a Library

Add this to your Cargo.toml:

[dependencies]
code-mesh-tui = "0.1"

🚀 Quick Start

Launch the TUI

# Start with default settings
code-mesh-tui

# Start with specific configuration
code-mesh-tui --config ~/.config/code-mesh/tui-config.toml

# Connect to remote Code-Mesh instance
code-mesh-tui --connect ws://localhost:8080

# Start in specific mode
code-mesh-tui --mode monitor

Basic Navigation

Tab / Shift+Tab    - Navigate between panels
Ctrl+P             - Open command palette
Ctrl+Q             - Quit application
?                  - Show help
Space              - Toggle pause/resume
F5                 - Refresh data

🎨 Interface Overview

Main Dashboard

┌─ Code-Mesh TUI v0.1.0 ─────────────────────────────────────────────────────┐
│ ⚡ Swarm: mesh-001 │ 🧠 Agents: 5/8 │ 📊 CPU: 45% │ 💾 RAM: 2.1GB │ ↗ Net │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─ Swarm Topology ─────────────┐ ┌─ Performance Metrics ──────────────────┐│
│  │                              │ │  CPU Usage        █████████░░ 89%      ││
│  │    [R1]────[C1]              │ │  Memory Usage     ███████░░░░ 67%      ││
│  │     │       │                │ │  Neural Ops/sec   ████████░░ 85%      ││
│  │    [A1]────[O1]              │ │  Network I/O      ██████░░░░ 59%      ││
│  │     │       │                │ │                                       ││
│  │    [A2]────[C2]              │ │  ┌─ Recent Tasks ─────────────────────┐││
│  │                              │ │  │ ✓ Code analysis    (2.3s)        │││
│  │  Legend:                     │ │  │ ⏳ Optimization    (45% done)    │││
│  │  [R] Researcher [C] Coder    │ │  │ ⏸ Documentation   (paused)       │││
│  │  [A] Analyst    [O] Optimizer│ │  │ ⌛ Testing         (queued)       │││
│  └──────────────────────────────┘ │  └───────────────────────────────────┘││
│                                   └─────────────────────────────────────────┘│
│                                                                             │
│  ┌─ Agent Details ──────────────────────────────────────────────────────────┐│
│  │ Agent ID: researcher-001                    Status: ⚡ Active             ││
│  │ Type: Researcher                           Uptime: 2h 15m 33s           ││
│  │ Cognitive Pattern: Adaptive                Tasks: 12 completed          ││
│  │ Neural Network: nn-1752..                  Success Rate: 98.3%          ││
│  │                                                                         ││
│  │ Current Task: "Analyze codebase structure and dependencies"             ││
│  │ Progress: ████████████████░░░░ 78%                                      ││
│  │ ETA: 45 seconds                                                         ││
│  └─────────────────────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────────────────────┘

Available Views

1. Dashboard View (Default)

• Overview of entire swarm
• Key performance metrics
• Active task monitoring
• Agent status summary

2. Swarm View

• Detailed swarm topology visualization
• Agent relationships and communication flows
• Network health and connectivity status
• Real-time topology optimization

3. Agent View

• Individual agent details
• Neural network visualization
• Performance metrics per agent
• Task history and success rates

4. Task View

• Task queue and execution status
• Detailed progress tracking
• Task results and outputs
• Performance analytics

5. Neural View

• Neural network architecture display
• Learning progress visualization
• Pattern recognition results
• Cross-agent knowledge sharing

6. Performance View

• Comprehensive system metrics
• Resource utilization graphs
• Performance trends and analytics
• Bottleneck identification

⌨️ Keyboard Shortcuts

Global Shortcuts

View-Specific Shortcuts

Dashboard View

Swarm View

Agent View

Task View

🎨 Themes and Customization

Built-in Themes

# Dark theme (default)
code-mesh-tui --theme dark

# Light theme
code-mesh-tui --theme light

# High contrast
code-mesh-tui --theme high-contrast

# Cyberpunk theme
code-mesh-tui --theme cyberpunk

# Minimalist theme
code-mesh-tui --theme minimal

Custom Theme Configuration

Create ~/.config/code-mesh/tui-theme.toml:

[colors]
background = "#1e1e1e"
foreground = "#d4d4d4"
primary = "#007acc"
secondary = "#ff6b6b"
success = "#4ade80"
warning = "#facc15"
error = "#ef4444"
accent = "#a855f7"

[borders]
style = "rounded"  # rounded, sharp, double, thick
color = "primary"

[graphs]
line_color = "primary"
fill_color = "secondary"
grid_color = "foreground"

Layout Customization

[layout]
show_borders = true
panel_spacing = 1
header_height = 3
footer_height = 2

[panels]
swarm_topology = { x = 0, y = 0, width = 50, height = 60 }
performance_metrics = { x = 50, y = 0, width = 50, height = 30 }
task_list = { x = 50, y = 30, width = 50, height = 30 }
agent_details = { x = 0, y = 60, width = 100, height = 40 }

🔧 Configuration

Configuration File (~/.config/code-mesh/tui-config.toml)

[display]
theme = "dark"
refresh_rate = 1000  # milliseconds
enable_mouse = true
enable_unicode = true

[performance]
max_fps = 60
buffer_size = 1000
enable_vsync = true

[networking]
connection_timeout = 5000
retry_attempts = 3
keepalive_interval = 30

[features]
enable_neural_viz = true
enable_audio_alerts = false
enable_notifications = true
show_debug_info = false

[keybindings]
quit = "Ctrl+Q"
help = "?"
refresh = "F5"
command_palette = "Ctrl+P"

🚀 Advanced Usage

Embedding in Applications

use code_mesh_tui::{TuiApp, TuiConfig};
use code_mesh_core::CodeMesh;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize Code-Mesh core
    let mesh = CodeMesh::new().await?;
    
    // Configure TUI
    let config = TuiConfig::default()
        .with_theme("cyberpunk")
        .with_refresh_rate(500)
        .with_mouse_support(true);
    
    // Create and run TUI
    let mut tui = TuiApp::new(mesh, config).await?;
    tui.run().await?;
    
    Ok(())
}

Custom Views

use code_mesh_tui::{View, ViewContext, RenderResult};

struct CustomMetricsView {
    data: Vec<Metric>,
}

impl View for CustomMetricsView {
    fn render(&mut self, ctx: &ViewContext) -> RenderResult {
        // Custom rendering logic
        Ok(())
    }
    
    fn handle_input(&mut self, input: InputEvent) -> bool {
        // Custom input handling
        false
    }
}

// Register custom view
tui.register_view("custom_metrics", Box::new(CustomMetricsView::new()));

Remote Monitoring

# Start Code-Mesh server with TUI endpoint
code-mesh serve --tui-port 8080

# Connect TUI to remote instance
code-mesh-tui --connect ws://remote-server:8080

# SSH tunnel for secure connection
ssh -L 8080:localhost:8080 remote-server
code-mesh-tui --connect ws://localhost:8080

🎯 Performance Optimization

For Large Swarms (10+ agents)

[performance]
# Reduce refresh rate for better performance
refresh_rate = 2000
max_fps = 30

# Limit data retention
buffer_size = 500
max_history = 100

# Disable expensive features
enable_neural_viz = false
show_topology_animation = false

For Resource-Constrained Systems

[display]
# Use minimal theme
theme = "minimal"
enable_unicode = false

[features]
# Disable non-essential features
enable_audio_alerts = false
enable_notifications = false
show_debug_info = false

🐛 Troubleshooting

Common Issues

Issue: TUI doesn't display correctly Solution: Ensure terminal supports 256 colors and Unicode

Issue: High CPU usage Solution: Increase refresh_rate in config (e.g., 2000ms)

Issue: Connection timeouts Solution: Check network connectivity and increase connection_timeout

Issue: Garbled display Solution: Try --theme minimal or disable Unicode

Debug Mode

# Enable debug logging
export CODE_MESH_TUI_LOG=debug

# Run with debug output
code-mesh-tui --debug 2>debug.log

# Capture screen output
code-mesh-tui --capture-output tui-output.txt

📚 Documentation

• TUI User Guide
• Theme Development
• Custom Views
• API Reference

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

📜 License

This project is licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT License (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

👨‍💻 Creator

Created by ruv - Innovator in AI-driven development tools and distributed systems.

Repository: github.com/ruvnet/code-mesh