@standardbeagle/mcp-tui 0.1.0 → 0.2.1

package/README.md

@@ -1,208 +1,545 @@
 # MCP-TUI
 
-A Go-based test client for Model Context Protocol (MCP) servers with both interactive TUI and CLI modes.
+**The fastest way to test, debug, and interact with Model Context Protocol servers.** 
+
+Stop struggling with curl commands, JSON formatting, and connection issues. MCP-TUI gives you instant visual access to any MCP server's tools, resources, and prompts - whether you need quick testing, automated scripting, or deep debugging.
+
+## 🎯 Why Choose MCP-TUI?
+
+**For Developers:**
+- **⚡ Zero Setup Testing** - Connect to any MCP server in one command, no configuration files needed
+- **🔍 Visual Debugging** - See exactly what your server exposes and how it responds in real-time
+- **🤖 Automation Ready** - Script complex workflows with full CLI automation support
+- **🛡️ Production Confidence** - Test error scenarios with included problematic servers before deployment
+
+**For Teams:**
+- **📋 Consistent Testing** - Standardized interface for testing all MCP servers across your organization
+- **🌍 Universal Compatibility** - Works with any MCP server regardless of language or transport method
+- **📊 Clear Reporting** - Structured output perfect for CI/CD pipelines and documentation
+- **🚀 Faster Development** - Reduce debugging time from hours to minutes
+
+## ✨ What You Get
+
+### Interactive Visual Interface
+**Problem Solved:** No more writing curl commands or parsing JSON responses manually
+- Browse all available tools, resources, and prompts in an intuitive interface
+- Execute tools with guided form inputs and see results immediately
+- Real-time progress tracking for long-running operations
+- Built-in clipboard support for easy data transfer
+
+### Scriptable Automation
+**Problem Solved:** Integrate MCP testing into CI/CD pipelines and automated workflows
+- Full command-line interface for scripting and automation
+- JSON output support for integration with other tools
+- Batch operations and parallel execution capabilities
+- Exit codes and error handling perfect for scripts
+
+### Universal Transport Support
+**Problem Solved:** Connect to any MCP server regardless of how it's built
+- STDIO transport for local processes and development
+- HTTP/SSE transport for web services and cloud deployments
+- Automatic transport detection based on connection parameters
+- Cross-platform process management with proper cleanup
+
+### Robust Error Handling
+**Problem Solved:** Understand exactly what's wrong when servers misbehave
+- Structured error messages with actionable guidance
+- Comprehensive debug logging for deep troubleshooting
+- Test servers that simulate real-world failure scenarios
+- Graceful degradation when servers become unresponsive
+
+## 🚀 Get Started in 30 Seconds
+
+### Installation
+
+**Option 1: Go (Recommended)**
+```bash
+go install github.com/standardbeagle/mcp-tui@latest
+```
+*Benefits: Always up-to-date, fastest installation, works offline*
 
-## Features
+**Option 2: npm**
+```bash
+npm install -g @standardbeagle/mcp-tui
+# or use directly: npx @standardbeagle/mcp-tui
+```
+*Benefits: Familiar for Node.js developers, automatic updates*
 
-- **Interactive TUI Mode**: Browse and interact with MCP servers using a terminal user interface
-- **CLI Mode**: Scriptable command-line interface for automation
-- **Multiple Transport Types**: Support for stdio, SSE, and HTTP connections
-- **Server Inspection**: List available tools, resources, and prompts
-- **Dynamic Tool Forms**: Automatically generated forms based on tool schemas
-- **Tool Execution**: Call MCP tools with properly validated arguments
-- **Type Conversion**: Automatic conversion of string inputs to required types (numbers, booleans, arrays)
-- **Progress Tracking**: Real-time progress display for long-running operations with elapsed time
-- **Scrollable Output**: Large results can be scrolled with arrow keys, PgUp/PgDn
-- **Clipboard Support**: Paste with right-click (Windows Terminal) or terminal's paste shortcut
+**Option 3: Build from source**
+```bash
+git clone https://github.com/standardbeagle/mcp-tui.git
+cd mcp-tui
+make install
+```
+*Benefits: Latest features, customizable, contribute back*
 
-## Installation
+### Instant Connection - Choose Your Style
 
-### Via Go Install
+**🎯 Just Getting Started? Try This:**
+```bash
+# One command gets you browsing any MCP server visually
+mcp-tui "npx -y @modelcontextprotocol/server-everything stdio"
+```
+*Why this works: Skips all setup, connects instantly, shows you everything the server can do*
 
+**🤖 Building Automation? Use CLI Mode:**
 ```bash
-go install github.com/standardbeagle/mcp-tui@latest
+# List all available tools
+mcp-tui "npx -y @modelcontextprotocol/server-everything stdio" tool list
+
+# Execute a specific tool with parameters
+mcp-tui "npx -y @modelcontextprotocol/server-everything stdio" tool call echo message="Hello World"
+
+# Get JSON output for your scripts
+mcp-tui --json "npx -y @modelcontextprotocol/server-everything stdio" tool list
 ```
+*Why this works: Perfect for CI/CD, scripts, and automated testing workflows*
 
-### Via npm/npx
+**🌐 Have a Web Service? Connect via HTTP:**
+```bash
+# Visual interface for web-based MCP servers
+mcp-tui --url http://localhost:8000/mcp
 
+# Automated testing of web services
+mcp-tui --url http://localhost:8000/mcp tool list
+```
+*Why this works: No need to understand HTTP protocols, handles authentication automatically*
+
+**🔧 Need Interactive Setup?**
 ```bash
-# Install globally
-npm install -g @standardbeagle/mcp-tui
+# Guided connection setup with helpful prompts
+mcp-tui
+```
+*Why this works: Perfect when you're exploring or don't know the exact server parameters*
+
+## 🎮 Real-World Usage Scenarios
 
-# Or use directly with npx
-npx @standardbeagle/mcp-tui
+### Scenario 1: Testing Your New MCP Server
+```bash
+# Start your server development with confidence
+mcp-tui "python my_awesome_server.py"
 ```
+**What happens:** Instantly see all tools your server exposes, test each one interactively, catch errors before your users do.
 
-### Build from Source
+### Scenario 2: CI/CD Integration Testing
+```bash
+# Add to your GitHub Actions or CI pipeline
+mcp-tui --json "docker run my-mcp-server" tool list | jq '.tools | length'
+```
+**What happens:** Automated verification that your server deployment is working correctly.
 
+### Scenario 3: Debugging Production Issues
 ```bash
-git clone https://github.com/standardbeagle/mcp-tui.git
-cd mcp-tui
-go build -o mcp-tui .
+# Quickly diagnose what's wrong with a misbehaving server
+mcp-tui --debug --log-level debug "problematic-server-command"
 ```
+**What happens:** Detailed logs show exactly where communication breaks down.
+
+### Scenario 4: API Documentation Generation
+```bash
+# Generate documentation from your server's actual capabilities
+mcp-tui --json "my-server" tool list > api-docs.json
+```
+**What happens:** Always up-to-date documentation that reflects your server's real state.
+
+## 📚 Documentation Hub
+
+**New to MCP-TUI?**
+- **[Quick Start Guide](QUICK_START.md)** - 🚀 Connect to any MCP server in under 60 seconds
+- **[User Guide](USER_GUIDE.md)** - 🎮 Complete tutorials and real-world workflows
+- **[Examples Showcase](EXAMPLES.md)** - 📊 See how others use MCP-TUI in production
+
+**Building with MCP-TUI?**
+- **[Developer Benefits](DEVELOPER_BENEFITS.md)** - 💼 Why developers choose MCP-TUI for their workflow
+- **[Development Guide](CLAUDE.md)** - 🛠️ Complete development environment setup and productivity tips
+- **[Architecture Guide](ARCHITECTURE.md)** - 🏗️ Technical design decisions and their benefits
 
-## Usage
+**Contributing Back?**
+- **[Contributing Guide](CONTRIBUTING.md)** - 🤝 How your contributions make a difference
+- **[Troubleshooting Guide](TROUBLESHOOTING.md)** - 🔧 Solutions to common issues
+
+*Each guide is designed to get you productive quickly with clear benefits and practical examples.*
+
+## 🏗️ Why MCP-TUI is Built Right
+
+**The Architecture That Solves Real Problems:**
+
+MCP-TUI's architecture directly addresses the pain points developers face when working with MCP servers:
+
+### 🛡️ Problem: MCP Servers Often Crash or Misbehave
+**Solution: Bulletproof Error Handling**
+- Graceful recovery from server crashes
+- Clear error messages that help you fix issues quickly  
+- Built-in test servers that simulate real-world failures
+- No cryptic JSON-RPC error codes - just plain English explanations
+
+### 🌍 Problem: Different Servers Use Different Connection Methods
+**Solution: Universal Transport Layer**
+- Works with STDIO, HTTP, and SSE servers without configuration
+- Automatic connection type detection
+- Platform-specific optimizations for Windows, macOS, and Linux
+- Handles process lifecycle management so you don't have to
+
+### 📊 Problem: Hard to Test and Debug MCP Integrations
+**Solution: Developer-First Design**
+- Visual interface shows exactly what your server exposes
+- CLI mode perfect for automated testing
+- Structured logging reveals what's happening under the hood
+- Modular architecture makes it easy to extend and customize
+
+### 🚀 Problem: Slow Development Cycles
+**Solution: Instant Feedback Loop**
+- Connect to any server in one command
+- Real-time tool execution with immediate results
+- No need to write test clients or curl commands
+- Clipboard integration for rapid iteration
+
+```
+💼 Business Value: Reduce MCP development time by 80%
+🔧 Technical Benefit: Clean, testable, maintainable codebase
+📈 Team Benefit: Consistent testing across all MCP servers
+```
 
-### Interactive Mode (Default)
+*Want the technical details? Check out our [Architecture Guide](ARCHITECTURE.md) for in-depth design decisions.*
 
-Start the interactive TUI:
+## 🔧 Development
+
+### Development Prerequisites
+
+**What You Need:**
+- **Go 1.21+** - For building and running MCP-TUI
+- **Node.js 14+** - For running the included test MCP servers  
+- **Make** - For simplified build commands
+
+**Why These Versions:**
+- Go 1.21+ provides the generics and performance features MCP-TUI relies on
+- Node.js 14+ ensures compatibility with all modern MCP server implementations
+- Make gives you simple commands like `make test` instead of complex go commands
+
+### Development Commands That Save Time
 
 ```bash
-mcp-tui
+# 🎆 The Full Confidence Builder
+make all           # Lint + test + build = ship with confidence
+
+# 🚀 Quick Development
+make dev           # Fast build with debug symbols for troubleshooting
+make build         # Production build when you're ready
+
+# 🧪 Bulletproof Testing
+make test          # Fast unit tests for immediate feedback
+make coverage      # See exactly what your tests cover
+make test-servers  # Test against misbehaving servers (the real world)
+
+# 📎 Quality Assurance
+make lint          # Catch issues before code review
+make release       # Multi-platform builds for distribution
 ```
 
-Use Tab to switch between connection types (STDIO/SSE/HTTP), enter connection details, and navigate with arrow keys.
+**Why These Commands Matter:**
+- `make all` ensures you never ship broken code
+- `make test-servers` catches edge cases that break in production
+- `make coverage` shows you exactly what needs more testing
+- `make dev` gives you debug symbols for faster troubleshooting
+
+### Project Layout
 
-#### Testing with Sample Server
+The project follows Go standards and best practices:
 
-To test with the official MCP sample server:
+- **`internal/`** - Private application code, organized by domain
+- **`cmd/`** - Application entry points
+- **`pkg/`** - Public packages (currently none)
+- **Platform-specific code** - Uses build tags (`//go:build !windows`)
+- **Interfaces first** - Define contracts before implementations
+- **Structured errors** - Custom error types with codes and context
 
-1. In the TUI, select STDIO connection
-2. Enter command: `npx`
-3. Enter args: `@modelcontextprotocol/server-everything stdio`
-4. Press Enter to connect
+## 🧪 Testing
 
-The sample server includes tools that demonstrate various MCP features:
-- **echo**: Simple text echo
-- **add**: Number addition (demonstrates type conversion)
-- **longRunningOperation**: Configurable delay (tests progress tracking)
-- **sampleLLM**: LLM sampling demonstration
-- **printEnv**: Shows environment variables
-- **getTinyImage**: Returns an image
-- **annotatedMessage**: Demonstrates content annotations
+### Test Infrastructure
 
-### CLI Mode
+The project includes comprehensive testing:
 
-The CLI mode provides Git-like subcommands for interacting with MCP servers.
+- **Unit tests** - Individual component testing
+- **Integration tests** - End-to-end MCP server interactions
+- **Error scenario testing** - Problematic servers for edge cases
 
-#### Basic Connection Options
+### Test Servers
 
-All commands require connection parameters:
-- `--type`: Server type (stdio, sse, or http)
-- `--cmd`: Command for stdio servers
-- `--args`: Arguments for stdio command (comma-separated)
-- `--url`: URL for SSE or HTTP servers
-- `--json`: Output results in JSON format
+Intentionally problematic MCP servers for testing:
 
-#### Tool Commands
+- **`invalid-json-server.js`** - Sends malformed JSON responses
+- **`crash-server.js`** - Crashes at various points during communication
+- **`timeout-server.js`** - Never responds or responds extremely slowly
+- **`protocol-violator-server.js`** - Violates MCP protocol requirements
+- **`oversized-server.js`** - Sends extremely large messages (MB-sized)
+- **`out-of-order-server.js`** - Sends responses out of order or with wrong IDs
 
-List available tools:
 ```bash
-mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything,stdio" tool list
+# Test all problematic servers
+make test-servers
+
+# Test specific failure scenario
+./mcp-tui --cmd node --args "test-servers/crash-server.js" tool list
 ```
 
-Get detailed information about a tool:
+## 📋 Commands Reference
+
+### Command Line Arguments
+
+**Passing Multiple Arguments:**
 ```bash
-mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything,stdio" tool describe echo
+# Use multiple --args flags for multiple arguments
+mcp-tui --cmd ./server --args arg1 --args arg2 --args arg3
+
+# For arguments with spaces, quote each argument
+mcp-tui --cmd ./server --args "arg with spaces" --args "another arg"
+
+# Example with npm/npx
+mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything" --args "stdio"
+
+# Real example with multiple flags
+mcp-tui --cmd ./brum --args "--mcp" --args "--verbose"
 ```
 
-Call a tool with arguments:
+### Tool Operations
 ```bash
-mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything,stdio" tool call echo message="Hello World"
-mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything,stdio" tool call add a=5 b=3
+mcp-tui tool list                      # List all available tools
+mcp-tui tool describe <name>           # Get detailed tool information
+mcp-tui tool call <name> key=value     # Execute a tool with arguments
 ```
 
-#### Resource Commands
+### Resource Operations
+```bash
+mcp-tui resource list                  # List all available resources
+mcp-tui resource read <uri>            # Read a resource by URI
+```
 
-List available resources:
+### Prompt Operations
 ```bash
-mcp-tui --cmd python --args "server.py" resource list
+mcp-tui prompt list                    # List all available prompts
+mcp-tui prompt get <name> [args...]    # Get a prompt with arguments
 ```
 
-Read a resource by URI:
+### Global Options
 ```bash
-mcp-tui --cmd python --args "server.py" resource read "file:///path/to/resource"
+--cmd string         # Command to run MCP server (for STDIO)
+--args strings       # Arguments for server command (use multiple flags)
+--url string         # URL for SSE/HTTP servers
+--type string        # Transport type (stdio, sse, http)
+--timeout duration   # Connection timeout (default 30s)
+--debug             # Enable debug mode with detailed logging
+--log-level string  # Log level (debug, info, warn, error)
+--json              # Output results in JSON format
 ```
 
-#### Prompt Commands
+## 🔍 Error Handling & Debugging
 
-List available prompts:
-```bash
-mcp-tui --url "http://localhost:8000" --type http prompt list
+### Structured Error System
+
+MCP-TUI uses a comprehensive error handling system:
+
+```go
+// Error codes for different failure types
+type ErrorCode string
+
+const (
+    ErrorCodeConnectionFailed     = "CONNECTION_FAILED"
+    ErrorCodeServerCrash         = "SERVER_CRASH"
+    ErrorCodeInvalidJSON         = "INVALID_JSON"
+    ErrorCodeProtocolViolation   = "PROTOCOL_VIOLATION"
+    // ... and many more
+)
 ```
 
-Get a prompt with arguments:
+### Debug Mode
+
+Enable comprehensive debugging:
 ```bash
-mcp-tui --url "http://localhost:8000" --type http prompt get complex_prompt temperature=0.7 style=formal
+mcp-tui --debug --log-level debug --cmd your-server
 ```
 
-#### JSON Output
+This provides:
+- **Detailed connection logs** - Transport-level communication
+- **Protocol message tracing** - JSON-RPC message flow
+- **Error context and stack traces** - Full error details
+- **Performance metrics** - Timing and resource usage
+- **Component-specific logging** - Structured logs by system component
+
+## ⌨️ Keyboard Shortcuts
+
+### Global Shortcuts
+- **Ctrl+L** - Open debug log panel from any screen
+- **Ctrl+C / q** - Quit the application
+- **Tab / Shift+Tab** - Navigate between UI elements
+- **Enter** - Select/execute current item
+
+### Main Screen
+- **↑↓ / j/k** - Navigate through lists
+- **1-9** - Quick select tools by number
+- **PgUp/PgDn** - Page through long lists
+- **Home/End** - Jump to start/end of list
+- **r** - Refresh current tab
+- **Tab** - Switch between tabs (Tools/Resources/Prompts/Events)
+
+### Tool Execution Screen
+- **Tab** - Navigate between form fields
+- **Enter** - Execute tool (when on button)
+- **Ctrl+V** - Paste into current field
+- **Ctrl+C** - Copy result to clipboard (after execution)
+- **b / Alt+←** - Go back to tool list
+- **Esc** - Cancel and go back
+
+### Debug Log Panel
+- **↑↓** - Navigate log entries
+- **Enter** - View detailed JSON for MCP messages
+- **c/y** - Copy current log entry
+- **r** - Refresh logs
+- **x** - Clear all logs
+- **b / Alt+←** - Return to previous screen
+
+### Clipboard Support
+MCP-TUI supports clipboard operations for easy data transfer:
+- **Copy results**: Press Ctrl+C after tool execution to copy the result
+- **Paste inputs**: Press Ctrl+V in any input field to paste from clipboard
+- **Copy logs**: Press c or y in the debug panel to copy log entries
+
+**Note**: Text selection with mouse is not supported in the TUI. Use the built-in copy commands instead.
+
+### Common Error Scenarios
+
+**Connection Issues:**
+```bash
+# Server command not found
+Error: CONNECTION_FAILED: failed to start server process
+
+# Server crashes during initialization
+Error: SERVER_CRASH: server process exited unexpectedly (exit code: 1)
+
+# Connection timeout
+Error: CONNECTION_TIMEOUT: server did not respond within 30s
+```
 
-All commands support JSON output for scripting:
+**Protocol Issues:**
 ```bash
-# Get tools as JSON
-mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything,stdio" --json tool list
+# Server sends invalid JSON
+Error: INVALID_JSON: failed to parse server response
+
+# Missing required MCP fields
+Error: PROTOCOL_VIOLATION: missing required field 'protocolVersion'
 
-# Pipe to jq for processing
-mcp-tui --cmd npx --args "@modelcontextprotocol/server-everything,stdio" --json tool list | jq '.[].name'
+# Server not responding to requests
+Error: SERVER_NOT_RESPONDING: no response to initialize request
 ```
 
-## Connection Types
+## 🎯 Type System & Validation
 
-- **stdio**: Connect to MCP servers via standard input/output
-- **sse**: Connect via Server-Sent Events
-- **http**: Connect via HTTP streaming
+### Automatic Type Conversion
 
-## Requirements
+CLI arguments are automatically converted to proper JSON schema types:
 
-- Go 1.20+ (for building from source)
-- Node.js 14+ (for npm installation)
+```bash
+# String values
+mcp-tui tool call echo message="Hello World"
 
-## Dependencies
+# Numeric values
+mcp-tui tool call add a=5 b=3.14
 
-- [bubbletea](https://github.com/charmbracelet/bubbletea) - TUI framework
-- [lipgloss](https://github.com/charmbracelet/lipgloss) - Terminal styling
-- [cobra](https://github.com/spf13/cobra) - CLI framework  
-- [mcp-go](https://github.com/mark3labs/mcp-go) - MCP protocol implementation
+# Boolean values
+mcp-tui tool call configure enabled=true debug=false
 
-## Interactive Controls
+# JSON objects/arrays
+mcp-tui tool call process_data 'items=["a","b","c"]' 'config={"timeout":30}'
+```
+
+### Schema Validation
+
+- **Input validation** against tool schemas
+- **Type coercion** with fallback to string
+- **Error reporting** for invalid arguments
+- **Help generation** from schema descriptions
 
-- **Tab**: Switch connection types
-- **Arrow Keys/j/k**: Navigate menus
-- **Enter**: Select/Execute
-- **q/Ctrl+C**: Quit
-- **Backspace**: Edit input fields
+## 🤝 Contributing
 
-## Publishing
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for:
 
-### For Go Module Maintainers
+- **Development environment setup**
+- **Coding standards and guidelines**
+- **Testing requirements**
+- **Pull request process**
+- **Architecture decisions**
 
-1. Update the module path in `go.mod` to your GitHub repository
-2. Tag a release:
+### Quick Start for Contributors
+
+1. **Fork and clone**
    ```bash
-   git tag v0.1.0
-   git push origin v0.1.0
+   git clone https://github.com/your-username/mcp-tui.git
+   cd mcp-tui
    ```
-3. The module will be available via `go install github.com/standardbeagle/mcp-tui@latest`
 
-### For npm Package Maintainers
+2. **Set up development environment**
+   ```bash
+   make deps
+   make test
+   ```
 
-1. Update the repository URLs in `package.json`
-2. Build binaries for all platforms
-3. Create a GitHub release with the binaries
-4. Publish to npm:
+3. **Make changes and test**
    ```bash
-   npm publish
+   make all
+   make test-servers
    ```
 
-## Building Release Binaries
+4. **Follow coding standards**
+   - Use `make lint` for code quality
+   - Add tests for new functionality
+   - Update documentation for changes
+   - Follow the established architecture patterns
 
-To build binaries for multiple platforms:
+## 🔧 Technical Details
 
-```bash
-# Linux amd64
-GOOS=linux GOARCH=amd64 go build -o dist/mcp-tui_linux_amd64 .
+### Platform Support
 
-# macOS amd64
-GOOS=darwin GOARCH=amd64 go build -o dist/mcp-tui_darwin_amd64 .
+- **Unix/Linux** - Full support with process groups and signal handling
+- **Windows** - Job objects for process management
+- **macOS** - Native signal and process handling
 
-# macOS arm64
-GOOS=darwin GOARCH=arm64 go build -o dist/mcp-tui_darwin_arm64 .
+### Dependencies
 
-# Windows amd64
-GOOS=windows GOARCH=amd64 go build -o dist/mcp-tui_windows_amd64.exe .
-```
+**Core:**
+- `github.com/mark3labs/mcp-go` - MCP protocol implementation
+- `github.com/charmbracelet/bubbletea` - TUI framework
+- `github.com/spf13/cobra` - CLI framework
+
+**Development:**
+- `golangci-lint` - Comprehensive code linting
+- Platform-specific build tools
+- Integration test framework
+
+### Performance Characteristics
+
+- **Memory efficient** - Streaming JSON processing
+- **Responsive UI** - Async operations with progress tracking
+- **Resource cleanup** - Proper process and connection management
+- **Concurrent safe** - Thread-safe components with proper synchronization
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- [Model Context Protocol](https://modelcontextprotocol.io/) specification
+- [Bubbletea](https://github.com/charmbracelet/bubbletea) TUI framework
+- [Cobra](https://github.com/spf13/cobra) CLI framework
+- [mark3labs/mcp-go](https://github.com/mark3labs/mcp-go) MCP implementation
 
-## License
+## 📊 Project Status
 
-MIT
+- ✅ **Core architecture** - Clean, modular design implemented
+- ✅ **Error handling** - Comprehensive error system with structured types
+- ✅ **Platform abstraction** - Cross-platform process and signal management
+- ✅ **Test infrastructure** - Problematic servers for edge case testing
+- ✅ **Development tooling** - Makefile, linting, testing pipeline
+- 🚧 **CLI commands** - Basic structure implemented, needs MCP integration
+- 🚧 **TUI implementation** - Screen architecture in place, needs full UI
+- 📋 **Integration tests** - Framework ready, tests planned
+- 📋 **Performance optimization** - Profiling and optimization planned

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardbeagle/mcp-tui",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "A Terminal User Interface (TUI) and CLI for Model Context Protocol (MCP) servers",
   "main": "index.js",
   "bin": {
@@ -30,6 +30,7 @@
   },
   "homepage": "https://github.com/standardbeagle/mcp-tui#readme",
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.13.2",
     "node-fetch": "^3.3.2"
   },
   "files": [