feat(mcp-test-harness): implement MCP ecosystem integration framework

- Add comprehensive ecosystem integration module with templates, benchmarks, community, and server profiles
- Implement TemplateManager with built-in templates for common MCP server patterns:
  - Basic compliance template for protocol testing
  - Filesystem server template with security testing
  - Database server template with SQL injection protection
  - API wrapper template with rate limiting tests
  - Development tool template with performance requirements
- Add PopularServers registry with pre-built configurations for major MCP servers:
  - CodePrism MCP Server for code analysis
  - Filesystem MCP Server from Anthropic
  - SQLite MCP Server for database operations
  - Weather MCP Server as API wrapper example
- Implement BenchmarkSuite for performance testing and baseline comparison
- Add CommunityConfig for test sharing and collaboration features
- Create comprehensive CLI commands for ecosystem integration:
  - 'ecosystem list-servers' to browse popular servers
  - 'ecosystem template' to generate server-specific templates
  - 'ecosystem templates' to list available test templates
  - 'ecosystem generate' to create specs from templates with variables
  - 'ecosystem benchmark' for performance testing with baseline comparison
- Support template variable substitution for customizable configurations
- Add server profiles with popularity scores, tags, and metadata
- Include installation instructions and repository links for each server
- Implement search functionality by tags and popularity ranking
- Add export/import capabilities for shareable test configurations

closes #105

Author: milliondreams

crates/mcp-test-harness/src/ecosystem/benchmarks.rs

@@ -0,0 +1,85 @@
+//! Performance Benchmarking Framework
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::Duration;
+
+/// Performance benchmark result
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BenchmarkResult {
+    pub test_name: String,
+    pub duration: Duration,
+    pub memory_usage_mb: f64,
+    pub operations_per_second: f64,
+    pub success: bool,
+    pub metadata: HashMap<String, serde_json::Value>,
+}
+
+/// Performance baseline for comparison
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PerformanceBaseline {
+    pub name: String,
+    pub version: String,
+    pub baseline_results: HashMap<String, BenchmarkResult>,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+}
+
+/// Benchmark suite for performance testing
+#[derive(Debug)]
+pub struct BenchmarkSuite {
+    pub name: String,
+    pub benchmarks: Vec<BenchmarkResult>,
+    pub baseline: Option<PerformanceBaseline>,
+}
+
+impl BenchmarkSuite {
+    /// Create a new benchmark suite
+    pub fn new(name: String) -> Self {
+        Self {
+            name,
+            benchmarks: Vec::new(),
+            baseline: None,
+        }
+    }
+
+    /// Add benchmark result
+    pub fn add_result(&mut self, result: BenchmarkResult) {
+        self.benchmarks.push(result);
+    }
+
+    /// Set performance baseline
+    pub fn set_baseline(&mut self, baseline: PerformanceBaseline) {
+        self.baseline = Some(baseline);
+    }
+
+    /// Compare current results against baseline
+    pub fn compare_to_baseline(&self) -> Result<Vec<String>> {
+        let baseline = self
+            .baseline
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("No baseline set"))?;
+
+        let mut comparisons = Vec::new();
+
+        for result in &self.benchmarks {
+            if let Some(baseline_result) = baseline.baseline_results.get(&result.test_name) {
+                let duration_diff = ((result.duration.as_millis() as f64
+                    - baseline_result.duration.as_millis() as f64)
+                    / baseline_result.duration.as_millis() as f64)
+                    * 100.0;
+
+                let memory_diff = ((result.memory_usage_mb - baseline_result.memory_usage_mb)
+                    / baseline_result.memory_usage_mb)
+                    * 100.0;
+
+                comparisons.push(format!(
+                    "{}: Duration {:+.1}%, Memory {:+.1}%",
+                    result.test_name, duration_diff, memory_diff
+                ));
+            }
+        }
+
+        Ok(comparisons)
+    }
+}

crates/mcp-test-harness/src/ecosystem/community.rs

@@ -0,0 +1,142 @@
+//! Community Features for Test Sharing and Collaboration
+
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+
+/// Community configuration for sharing and collaboration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CommunityConfig {
+    pub sharing_enabled: bool,
+    pub registry_url: Option<String>,
+    pub user_credentials: Option<String>,
+    pub local_cache_dir: String,
+}
+
+/// Shareable test configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestShare {
+    pub name: String,
+    pub version: String,
+    pub author: String,
+    pub description: String,
+    pub server_type: String,
+    pub test_config: serde_json::Value,
+    pub tags: Vec<String>,
+    pub downloads: u64,
+    pub rating: f32,
+    pub created_at: chrono::DateTime<chrono::Utc>,
+    pub updated_at: chrono::DateTime<chrono::Utc>,
+}
+
+/// Test result comparison
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResultComparison {
+    pub test_name: String,
+    pub baseline_result: serde_json::Value,
+    pub current_result: serde_json::Value,
+    pub differences: Vec<String>,
+    pub improvement_percentage: f64,
+}
+
+impl CommunityConfig {
+    /// Create default community configuration
+    pub fn new() -> Self {
+        Self {
+            sharing_enabled: false,
+            registry_url: Some("https://registry.mcp-test-harness.org".to_string()),
+            user_credentials: None,
+            local_cache_dir: "~/.mcp-test-harness/community".to_string(),
+        }
+    }
+
+    /// Enable test sharing
+    pub fn enable_sharing(&mut self, credentials: String) {
+        self.sharing_enabled = true;
+        self.user_credentials = Some(credentials);
+    }
+
+    /// Disable test sharing
+    pub fn disable_sharing(&mut self) {
+        self.sharing_enabled = false;
+        self.user_credentials = None;
+    }
+}
+
+impl TestShare {
+    /// Create a new test share
+    pub fn new(
+        name: String,
+        version: String,
+        author: String,
+        description: String,
+        server_type: String,
+        test_config: serde_json::Value,
+    ) -> Self {
+        let now = chrono::Utc::now();
+        Self {
+            name,
+            version,
+            author,
+            description,
+            server_type,
+            test_config,
+            tags: Vec::new(),
+            downloads: 0,
+            rating: 0.0,
+            created_at: now,
+            updated_at: now,
+        }
+    }
+
+    /// Add tags to the test share
+    pub fn with_tags(mut self, tags: Vec<String>) -> Self {
+        self.tags = tags;
+        self
+    }
+
+    /// Export to shareable format
+    pub fn export(&self) -> Result<String> {
+        serde_yaml::to_string(self).map_err(|e| anyhow::anyhow!("Export failed: {}", e))
+    }
+
+    /// Import from shareable format
+    pub fn import(data: &str) -> Result<Self> {
+        serde_yaml::from_str(data).map_err(|e| anyhow::anyhow!("Import failed: {}", e))
+    }
+}
+
+impl ResultComparison {
+    /// Create a new result comparison
+    pub fn new(
+        test_name: String,
+        baseline_result: serde_json::Value,
+        current_result: serde_json::Value,
+    ) -> Self {
+        let differences = Vec::new(); // FUTURE: Implement detailed diff analysis
+        let improvement_percentage = 0.0; // FUTURE: Calculate actual improvement
+
+        Self {
+            test_name,
+            baseline_result,
+            current_result,
+            differences,
+            improvement_percentage,
+        }
+    }
+
+    /// Get summary of differences
+    pub fn summary(&self) -> String {
+        format!(
+            "Test '{}': {} differences, {:+.1}% improvement",
+            self.test_name,
+            self.differences.len(),
+            self.improvement_percentage
+        )
+    }
+}
+
+impl Default for CommunityConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}

crates/mcp-test-harness/src/ecosystem/mod.rs

@@ -0,0 +1,16 @@
+//! MCP Ecosystem Integration Framework
+//!
+//! This module provides tools for integrating with the broader MCP ecosystem,
+//! including pre-built configurations for popular servers, template systems,
+//! performance benchmarking, and community features.
+
+pub mod benchmarks;
+pub mod community;
+pub mod servers;
+pub mod templates;
+
+// Re-export main types for public API
+pub use benchmarks::{BenchmarkResult, BenchmarkSuite, PerformanceBaseline};
+pub use community::{CommunityConfig, ResultComparison, TestShare};
+pub use servers::{PopularServers, ServerProfile, ServerTemplate};
+pub use templates::{TemplateManager, TemplateType, TestTemplate};