feat: Implement MCP Server Hot Reload Functionality

[codeman9]

🎯 Overview

This PR implements comprehensive MCP server hot reload functionality, allowing users to manage MCP servers during active chat sessions
without restarting the application. This addresses a significant developer experience friction point when working with MCP servers.

✨ Key Features

🔄 Server Management Commands

• /mcp reload [server-name] - Restart a specific server with updated configuration
• /mcp enable [server-name] - Enable a disabled server for the current session
• /mcp disable [server-name] - Disable an enabled server for the current session
• /mcp list - List all configured servers with current status
• /mcp sync - Sync running servers with configuration files

🎛️ Session State Management

• Session-only server state changes (reset on application restart)
• Override configuration file settings temporarily
• Clean separation between persistent and temporary state changes
• State isolation between different chat sessions

🔧 Configuration Management

• Re-read configuration files without application restart
• Validate configurations before applying changes (--validate-only)
• Detailed configuration information display (--verbose)
• Atomic configuration operations with proper rollback

🎨 Enhanced User Experience

• Progress Display: Real-time feedback with spinner animations and timing
• Context Filtering: Disabled server tools excluded from model context (reduces token usage)
• Tool Visibility: Disabled tools show as "* disabled" in /tools command
• Error Handling: Comprehensive error messages with actionable guidance
• Interactive/Non-Interactive: Adapts display based on terminal capabilities

🏗️ Architecture

New Components

• ServerReloadManager: Core server lifecycle management
• SessionServerState: Session-only state tracking
• ProgressDisplay: Async progress communication system
• ErrorDisplayManager: Centralized error handling with user guidance

Enhanced Components

• ToolManager: Extended with session state and hot reload capabilities
• McpArgs: Converted from simple display to full subcommand system
• Tool Registration: Intelligent duplicate prevention and dynamic registration

🔍 Implementation Highlights

Atomic Operations

All server operations are atomic - they either succeed completely or fail without leaving the system in an inconsistent state.

Intelligent Tool Registration

rust
// Prevents duplicate tool registration for originally-enabled servers
let has_existing_tools = tool_manager.schema.values()
.any(|spec| matches!(&spec.tool_origin, ToolOrigin::McpServer(name) if name == server_name));

if !has_existing_tools {
self.register_server_tools(&mut tool_manager, client_arc, server_name).await?;
}

Context Filtering

Disabled server tools are excluded from model context, reducing token usage while remaining visible to users:
• Before: All tools sent to model regardless of server state
• After: Only enabled server tools included in model context

Session State Tracking

rust
pub struct SessionServerState {
disabled_servers: HashSet,
enabled_servers: HashSet,
}

🧪 Testing Results

Functionality Verification

✅ Server Reload: Full restart with configuration refresh
✅ Enable/Disable: Session-only state changes work correctly
✅ Tool Registration: No duplicate tools, proper cleanup
✅ Context Filtering: Correct token usage optimization
✅ Configuration Sync: File changes applied without restart
✅ Error Handling: Graceful degradation, session continues
✅ Progress Display: Interactive and non-interactive modes

Token Usage Optimization

• Initial: 19,450 tokens (original tools)
• Disable: 12,170 tokens (tools filtered out) ✅
• Enable: 19,450 tokens (tools restored, no duplication) ✅
• Consistent cycles: ±7,280 tokens (correct tool count)

Build Quality

✅ Zero warnings - Clean, professional code
✅ Zero errors - All functionality verified
✅ All tests pass - Comprehensive validation
✅ Backward compatibility - Existing /mcp usage unchanged

🎯 Use Cases Addressed

1. Development Workflow: Reload servers after making changes to MCP server code
2. Configuration Management: Switch between different server configurations for different tasks
3. Resource Management: Temporarily disable resource-heavy servers when not needed
4. Troubleshooting: Restart unresponsive servers without losing chat context
5. Dynamic Configuration: Add/remove servers based on current project needs

🔄 Migration & Compatibility

Backward Compatibility

• Existing /mcp usage: Continues to work unchanged (shows server status)
• Configuration files: No changes to existing formats
• API stability: Maintains existing ToolManager public interface

Command Evolution

• Before: /mcp (display only)
• After: /mcp (display) + /mcp reload|enable|disable|list|sync (management)

📊 Code Quality

• 18 commits with clear, focused changes
• Comprehensive error handling with user-friendly messages
• Professional UX consistent with Q CLI patterns
• Complete API surface for future enhancements
• Extensive documentation and inline comments

🚀 Impact

This feature significantly improves the developer experience when working with MCP servers by:

1. Eliminating restart friction - No need to quit and restart Q CLI
2. Enabling rapid iteration - Quick server configuration changes
3. Optimizing resource usage - Context filtering reduces token consumption
4. Providing clear feedback - Professional progress display and error handling
5. Maintaining reliability - Atomic operations and graceful error recovery

Here is a sample chat log:

> /mcp

XcodeBuildMCP
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
✓ XcodeBuildMCP loaded in 2.12 s

fetch
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
✓ fetch loaded in 0.96 s

seqthink
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
✓ seqthink loaded in 1.09 s

amzn-mcp
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
✓ amzn-mcp loaded in 0.67 s

git
▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
✓ git loaded in 0.92 s


> What is my git status?

> I'll check your git status for you.


🛠️  Using tool: git_status from mcp server git
 ⋮ 
 ● Running git_status with the param:
 ⋮  {
 ⋮    "arguments": {
 ⋮      "repo_path": "/Volumes/workplace/amazon-q-developer-cli"
 ⋮    },
 ⋮    "name": "git_status"
 ⋮  }

Allow this action? Use 't' to trust (always allow) this tool for the session. [y/n/t]:

> y


 ⋮ 
 ● Completed in 0.62s


> Your git status shows:

• **Current branch**: feature/mcp-hot-reload (up to date with fork/feature/mcp-hot-reload)
• **Modified file**: crates/chat-cli/src/cli/chat/cli/profile.rs (not staged)
• **Untracked directory**: planning/
• **No staged changes** ready for commit

You have one modified file that needs to be staged if you want to commit it, and a new planning/ directory that's currently untracked.

> /mcp disable git

✓ Server 'git' disabled successfully in 0.61s

> What is my git status?

> I'll check your git status for you.


Tool validation failed: 
The tool, "git" is not supported by the client
> Let me check your git status using bash instead:


🛠️  Using tool: execute_bash
 ⋮ 
 ● I will run the following shell command: git status
 ⋮ 
 ↳ Purpose: Check git repository status


Allow this action? Use 't' to trust (always allow) this tool for the session. [y/n/t]:

> y

On branch feature/mcp-hot-reload
Your branch is up to date with 'fork/feature/mcp-hot-reload'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   crates/chat-cli/src/cli/chat/cli/profile.rs

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	planning/

no changes added to commit (use "git add" and/or "git commit -a")

 ⋮ 
 ● Completed in 0.35s


> Your git status shows:

• **Current branch**: feature/mcp-hot-reload (up to date with fork/feature/mcp-hot-reload)
• **Modified file**: crates/chat-cli/src/cli/chat/cli/profile.rs (not staged)
• **Untracked directory**: planning/
• **No staged changes** ready for commit

You have one modified file that needs to be staged if you want to commit it, and a new planning/ directory that's currently untracked.

> /mcp enable git

✓ Server 'git' enabled successfully in 1.07s

> What is my git status?

> I'll check your git status for you.


🛠️  Using tool: execute_bash
 ⋮ 
 ● I will run the following shell command: git status
 ⋮ 
 ↳ Purpose: Check git repository status


Allow this action? Use 't' to trust (always allow) this tool for the session. [y/n/t]:

> Use the git mcp tool.

> I'll use the git MCP tool to check your git status.


🛠️  Using tool: git_status from mcp server git
 ⋮ 
 ● Running git_status with the param:
 ⋮  {
 ⋮    "arguments": {
 ⋮      "repo_path": "/Volumes/workplace/amazon-q-developer-cli"
 ⋮    },
 ⋮    "name": "git_status"
 ⋮  }

Allow this action? Use 't' to trust (always allow) this tool for the session. [y/n/t]:

> y


 ⋮ 
 ● Completed in 0.55s


> Your git status shows:

• **Current branch**: feature/mcp-hot-reload (up to date with fork/feature/mcp-hot-reload)
• **Modified file**: crates/chat-cli/src/cli/chat/cli/profile.rs (not staged)
• **Untracked directory**: planning/
• **No staged changes** ready for commit

You have one modified file that needs to be staged if you want to commit it, and a new planning/ directory that's currently untracked.

>