diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourceHealthCheckHandler.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourceHealthCheckHandler.cs new file mode 100644 index 0000000..20c637e --- /dev/null +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourceHealthCheckHandler.cs @@ -0,0 +1,100 @@ +using ColaFlow.Modules.Mcp.Application.Services; +using ColaFlow.Modules.Mcp.Contracts.Resources; +using Microsoft.Extensions.Logging; + +namespace ColaFlow.Modules.Mcp.Application.Handlers; + +/// +/// Handler for 'resources/health' method +/// Checks availability and health of all registered resources +/// +public class ResourceHealthCheckHandler : IMcpMethodHandler +{ + private readonly ILogger _logger; + private readonly IMcpResourceRegistry _resourceRegistry; + + public string MethodName => "resources/health"; + + public ResourceHealthCheckHandler( + ILogger logger, + IMcpResourceRegistry resourceRegistry) + { + _logger = logger; + _resourceRegistry = resourceRegistry; + } + + public async Task HandleAsync(object? @params, CancellationToken cancellationToken) + { + _logger.LogDebug("Handling resources/health request"); + + var resources = _resourceRegistry.GetAllResources(); + var healthResults = new List(); + var totalResources = resources.Count; + var healthyResources = 0; + var unhealthyResources = 0; + + foreach (var resource in resources) + { + try + { + // Try to get descriptor - if this fails, resource is unhealthy + var descriptor = resource.GetDescriptor(); + + // Basic validation + var isHealthy = !string.IsNullOrWhiteSpace(descriptor.Uri) + && !string.IsNullOrWhiteSpace(descriptor.Name) + && descriptor.IsEnabled; + + if (isHealthy) + { + healthyResources++; + } + else + { + unhealthyResources++; + } + + healthResults.Add(new + { + uri = descriptor.Uri, + name = descriptor.Name, + category = descriptor.Category, + status = isHealthy ? "healthy" : "unhealthy", + isEnabled = descriptor.IsEnabled, + version = descriptor.Version + }); + } + catch (Exception ex) + { + unhealthyResources++; + _logger.LogError(ex, "Health check failed for resource {ResourceType}", resource.GetType().Name); + + healthResults.Add(new + { + uri = resource.Uri, + name = resource.Name, + category = resource.Category, + status = "error", + error = ex.Message + }); + } + } + + var overallStatus = unhealthyResources == 0 ? "healthy" : "degraded"; + + _logger.LogInformation("Resource health check completed: {Healthy}/{Total} healthy", + healthyResources, totalResources); + + var response = new + { + status = overallStatus, + totalResources = totalResources, + healthyResources = healthyResources, + unhealthyResources = unhealthyResources, + timestamp = DateTime.UtcNow, + resources = healthResults + }; + + return await Task.FromResult(response); + } +} diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourcesListMethodHandler.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourcesListMethodHandler.cs index aed882b..12ce5e2 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourcesListMethodHandler.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Handlers/ResourcesListMethodHandler.cs @@ -5,6 +5,7 @@ namespace ColaFlow.Modules.Mcp.Application.Handlers; /// /// Handler for the 'resources/list' MCP method +/// Returns categorized list of all available resources with full metadata /// public class ResourcesListMethodHandler : IMcpMethodHandler { @@ -25,10 +26,32 @@ public class ResourcesListMethodHandler : IMcpMethodHandler { _logger.LogDebug("Handling resources/list request"); - // Get all registered resource descriptors + // Get all registered resource descriptors with full metadata var descriptors = _resourceRegistry.GetResourceDescriptors(); + var categories = _resourceRegistry.GetCategories(); - _logger.LogInformation("Returning {Count} MCP resources", descriptors.Count); + _logger.LogInformation("Returning {Count} MCP resources in {CategoryCount} categories", + descriptors.Count, categories.Count); + + // Group by category for better organization + var resourcesByCategory = descriptors + .GroupBy(d => d.Category) + .OrderBy(g => g.Key) + .ToDictionary( + g => g.Key, + g => g.Select(d => new + { + uri = d.Uri, + name = d.Name, + description = d.Description, + mimeType = d.MimeType, + version = d.Version, + parameters = d.Parameters, + examples = d.Examples, + tags = d.Tags, + isEnabled = d.IsEnabled + }).ToArray() + ); var response = new { @@ -37,8 +60,18 @@ public class ResourcesListMethodHandler : IMcpMethodHandler uri = d.Uri, name = d.Name, description = d.Description, - mimeType = d.MimeType - }).ToArray() + mimeType = d.MimeType, + category = d.Category, + version = d.Version, + parameters = d.Parameters, + examples = d.Examples, + tags = d.Tags, + isEnabled = d.IsEnabled + }).ToArray(), + categories = categories.ToArray(), + resourcesByCategory = resourcesByCategory, + totalCount = descriptors.Count, + categoryCount = categories.Count }; return Task.FromResult(response); diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesGetResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesGetResource.cs index 8f7fcb6..ebada61 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesGetResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesGetResource.cs @@ -18,6 +18,8 @@ public class IssuesGetResource : IMcpResource public string Name => "Issue Details"; public string Description => "Get detailed information about an issue (Epic/Story/Task)"; public string MimeType => "application/json"; + public string Category => "Issues"; + public string Version => "1.0"; private readonly IProjectRepository _projectRepository; private readonly ITenantContext _tenantContext; diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesSearchResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesSearchResource.cs index 15fb019..42cdaa8 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesSearchResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/IssuesSearchResource.cs @@ -18,6 +18,8 @@ public class IssuesSearchResource : IMcpResource public string Name => "Issues Search"; public string Description => "Search issues with filters (status, priority, assignee, etc.)"; public string MimeType => "application/json"; + public string Category => "Issues"; + public string Version => "1.0"; private readonly IProjectRepository _projectRepository; private readonly ITenantContext _tenantContext; diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsGetResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsGetResource.cs index d822778..10399be 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsGetResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsGetResource.cs @@ -18,6 +18,8 @@ public class ProjectsGetResource : IMcpResource public string Name => "Project Details"; public string Description => "Get detailed information about a project"; public string MimeType => "application/json"; + public string Category => "Projects"; + public string Version => "1.0"; private readonly IProjectRepository _projectRepository; private readonly ITenantContext _tenantContext; @@ -33,6 +35,30 @@ public class ProjectsGetResource : IMcpResource _logger = logger; } + public McpResourceDescriptor GetDescriptor() + { + return new McpResourceDescriptor + { + Uri = Uri, + Name = Name, + Description = Description, + MimeType = MimeType, + Category = Category, + Version = Version, + Parameters = new Dictionary + { + { "id", "Project ID (GUID)" } + }, + Examples = new List + { + "GET colaflow://projects.get/123e4567-e89b-12d3-a456-426614174000", + "Returns: { id, name, key, description, status, epics: [...] }" + }, + Tags = new List { "projects", "details", "read-only" }, + IsEnabled = true + }; + } + public async Task GetContentAsync( McpResourceRequest request, CancellationToken cancellationToken) diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsListResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsListResource.cs index 71e3236..bfca876 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsListResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/ProjectsListResource.cs @@ -16,6 +16,8 @@ public class ProjectsListResource : IMcpResource public string Name => "Projects List"; public string Description => "List all projects in current tenant"; public string MimeType => "application/json"; + public string Category => "Projects"; + public string Version => "1.0"; private readonly IProjectRepository _projectRepository; private readonly ITenantContext _tenantContext; @@ -31,6 +33,27 @@ public class ProjectsListResource : IMcpResource _logger = logger; } + public McpResourceDescriptor GetDescriptor() + { + return new McpResourceDescriptor + { + Uri = Uri, + Name = Name, + Description = Description, + MimeType = MimeType, + Category = Category, + Version = Version, + Parameters = null, // No parameters required + Examples = new List + { + "GET colaflow://projects.list", + "Returns: { projects: [...], total: N }" + }, + Tags = new List { "projects", "list", "read-only" }, + IsEnabled = true + }; + } + public async Task GetContentAsync( McpResourceRequest request, CancellationToken cancellationToken) diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/SprintsCurrentResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/SprintsCurrentResource.cs index 32dd787..6daf198 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/SprintsCurrentResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/SprintsCurrentResource.cs @@ -17,6 +17,8 @@ public class SprintsCurrentResource : IMcpResource public string Name => "Current Sprint"; public string Description => "Get the currently active Sprint(s)"; public string MimeType => "application/json"; + public string Category => "Sprints"; + public string Version => "1.0"; private readonly IProjectRepository _projectRepository; private readonly ITenantContext _tenantContext; diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/UsersListResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/UsersListResource.cs index b0dc6d2..a5c0a45 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/UsersListResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Resources/UsersListResource.cs @@ -18,6 +18,8 @@ public class UsersListResource : IMcpResource public string Name => "Team Members"; public string Description => "List all team members in current tenant"; public string MimeType => "application/json"; + public string Category => "Users"; + public string Version => "1.0"; private readonly IUserRepository _userRepository; private readonly ITenantContext _tenantContext; diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IMcpResourceRegistry.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IMcpResourceRegistry.cs index 57b3019..6a8e2b9 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IMcpResourceRegistry.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IMcpResourceRegistry.cs @@ -4,7 +4,7 @@ namespace ColaFlow.Modules.Mcp.Application.Services; /// /// Registry for all MCP Resources -/// Manages resource discovery and routing +/// Manages resource discovery, routing, and categorization /// public interface IMcpResourceRegistry { @@ -27,4 +27,19 @@ public interface IMcpResourceRegistry /// Get all resource descriptors (for resources/list method) /// IReadOnlyList GetResourceDescriptors(); + + /// + /// Get resources by category + /// + IReadOnlyList GetResourcesByCategory(string category); + + /// + /// Get all categories + /// + IReadOnlyList GetCategories(); + + /// + /// Get resources grouped by category + /// + IReadOnlyDictionary> GetResourcesGroupedByCategory(); } diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IResourceDiscoveryService.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IResourceDiscoveryService.cs new file mode 100644 index 0000000..7ac0769 --- /dev/null +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/IResourceDiscoveryService.cs @@ -0,0 +1,22 @@ +using ColaFlow.Modules.Mcp.Contracts.Resources; + +namespace ColaFlow.Modules.Mcp.Application.Services; + +/// +/// Service for discovering MCP Resources via Assembly scanning +/// +public interface IResourceDiscoveryService +{ + /// + /// Discover all IMcpResource implementations in loaded assemblies + /// + /// List of discovered resource types + IReadOnlyList DiscoverResourceTypes(); + + /// + /// Discover and instantiate all resources + /// + /// Service provider for dependency injection + /// List of instantiated resources + IReadOnlyList DiscoverAndInstantiateResources(IServiceProvider serviceProvider); +} diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/McpResourceRegistry.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/McpResourceRegistry.cs index ae578fe..cdfef18 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/McpResourceRegistry.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/McpResourceRegistry.cs @@ -6,12 +6,14 @@ namespace ColaFlow.Modules.Mcp.Application.Services; /// /// Implementation of MCP Resource Registry +/// Enhanced with category support and dynamic registration /// public class McpResourceRegistry : IMcpResourceRegistry { private readonly ILogger _logger; private readonly Dictionary _resources = new(); private readonly List _resourceList = new(); + private readonly object _lock = new(); public McpResourceRegistry(ILogger logger) { @@ -20,51 +22,106 @@ public class McpResourceRegistry : IMcpResourceRegistry public void RegisterResource(IMcpResource resource) { - if (_resources.ContainsKey(resource.Uri)) + lock (_lock) { - _logger.LogWarning("Resource already registered: {Uri}. Overwriting.", resource.Uri); + if (_resources.ContainsKey(resource.Uri)) + { + _logger.LogWarning("Resource already registered: {Uri}. Overwriting.", resource.Uri); + _resourceList.Remove(_resources[resource.Uri]); + } + + _resources[resource.Uri] = resource; + _resourceList.Add(resource); + + _logger.LogInformation("Registered MCP Resource: {Uri} - {Name} [{Category}]", + resource.Uri, resource.Name, resource.Category); } - - _resources[resource.Uri] = resource; - _resourceList.Add(resource); - - _logger.LogInformation("Registered MCP Resource: {Uri} - {Name}", resource.Uri, resource.Name); } public IReadOnlyList GetAllResources() { - return _resourceList.AsReadOnly(); + lock (_lock) + { + return _resourceList.AsReadOnly(); + } } public IMcpResource? GetResourceByUri(string uri) { - // Try exact match first - if (_resources.TryGetValue(uri, out var resource)) + lock (_lock) { - return resource; - } - - // Try matching against URI templates (e.g., "colaflow://projects.get/{id}") - foreach (var registeredResource in _resourceList) - { - if (UriMatchesTemplate(uri, registeredResource.Uri)) + // Try exact match first + if (_resources.TryGetValue(uri, out var resource)) { - return registeredResource; + return resource; } - } - return null; + // Try matching against URI templates (e.g., "colaflow://projects.get/{id}") + foreach (var registeredResource in _resourceList) + { + if (UriMatchesTemplate(uri, registeredResource.Uri)) + { + return registeredResource; + } + } + + return null; + } } public IReadOnlyList GetResourceDescriptors() { - return _resourceList.Select(r => new McpResourceDescriptor + lock (_lock) { - Uri = r.Uri, - Name = r.Name, - Description = r.Description, - MimeType = r.MimeType - }).ToList().AsReadOnly(); + return _resourceList + .Select(r => r.GetDescriptor()) + .ToList() + .AsReadOnly(); + } + } + + /// + /// Get resources by category + /// + public IReadOnlyList GetResourcesByCategory(string category) + { + lock (_lock) + { + return _resourceList + .Where(r => r.Category.Equals(category, StringComparison.OrdinalIgnoreCase)) + .ToList() + .AsReadOnly(); + } + } + + /// + /// Get all categories + /// + public IReadOnlyList GetCategories() + { + lock (_lock) + { + return _resourceList + .Select(r => r.Category) + .Distinct() + .OrderBy(c => c) + .ToList() + .AsReadOnly(); + } + } + + /// + /// Get resources grouped by category + /// + public IReadOnlyDictionary> GetResourcesGroupedByCategory() + { + lock (_lock) + { + return _resourceList + .GroupBy(r => r.Category) + .ToDictionary(g => g.Key, g => g.ToList()) + .AsReadOnly(); + } } /// diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/ResourceDiscoveryService.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/ResourceDiscoveryService.cs new file mode 100644 index 0000000..8fb5a1e --- /dev/null +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Application/Services/ResourceDiscoveryService.cs @@ -0,0 +1,92 @@ +using System.Reflection; +using ColaFlow.Modules.Mcp.Contracts.Resources; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; + +namespace ColaFlow.Modules.Mcp.Application.Services; + +/// +/// Implementation of Resource Discovery Service +/// Scans assemblies to find all IMcpResource implementations +/// +public class ResourceDiscoveryService : IResourceDiscoveryService +{ + private readonly ILogger _logger; + + public ResourceDiscoveryService(ILogger logger) + { + _logger = logger; + } + + public IReadOnlyList DiscoverResourceTypes() + { + _logger.LogInformation("Starting MCP Resource discovery via Assembly scanning..."); + + var resourceTypes = new List(); + + // Get all loaded assemblies + var assemblies = AppDomain.CurrentDomain.GetAssemblies() + .Where(a => !a.IsDynamic && a.FullName != null && a.FullName.StartsWith("ColaFlow")) + .ToList(); + + _logger.LogDebug("Scanning {Count} assemblies for IMcpResource implementations", assemblies.Count); + + foreach (var assembly in assemblies) + { + try + { + var types = assembly.GetTypes() + .Where(t => typeof(IMcpResource).IsAssignableFrom(t) + && !t.IsInterface + && !t.IsAbstract + && t.IsClass) + .ToList(); + + if (types.Any()) + { + _logger.LogDebug("Found {Count} resources in assembly {Assembly}", + types.Count, assembly.GetName().Name); + resourceTypes.AddRange(types); + } + } + catch (ReflectionTypeLoadException ex) + { + _logger.LogWarning(ex, "Failed to load types from assembly {Assembly}", assembly.FullName); + } + } + + _logger.LogInformation("Discovered {Count} MCP Resource types", resourceTypes.Count); + + return resourceTypes.AsReadOnly(); + } + + public IReadOnlyList DiscoverAndInstantiateResources(IServiceProvider serviceProvider) + { + var resourceTypes = DiscoverResourceTypes(); + var resources = new List(); + + foreach (var resourceType in resourceTypes) + { + try + { + // Use DI to instantiate the resource (resolves dependencies automatically) + var resource = ActivatorUtilities.CreateInstance(serviceProvider, resourceType) as IMcpResource; + + if (resource != null) + { + resources.Add(resource); + _logger.LogDebug("Instantiated resource: {ResourceType} -> {Uri}", + resourceType.Name, resource.Uri); + } + } + catch (Exception ex) + { + _logger.LogError(ex, "Failed to instantiate resource type {ResourceType}", resourceType.FullName); + } + } + + _logger.LogInformation("Instantiated {Count} MCP Resources", resources.Count); + + return resources.AsReadOnly(); + } +} diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/IMcpResource.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/IMcpResource.cs index b74cd77..f3066c4 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/IMcpResource.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/IMcpResource.cs @@ -26,6 +26,35 @@ public interface IMcpResource /// string MimeType { get; } + /// + /// Resource category (e.g., "Projects", "Issues", "Sprints", "Users") + /// Default: "General" + /// + string Category => "General"; + + /// + /// Resource version (for future compatibility) + /// Default: "1.0" + /// + string Version => "1.0"; + + /// + /// Get resource descriptor with full metadata + /// + McpResourceDescriptor GetDescriptor() + { + return new McpResourceDescriptor + { + Uri = Uri, + Name = Name, + Description = Description, + MimeType = MimeType, + Category = Category, + Version = Version, + IsEnabled = true + }; + } + /// /// Get resource content /// diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/McpResourceDescriptor.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/McpResourceDescriptor.cs index 61b8885..1d1ff85 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/McpResourceDescriptor.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Contracts/Resources/McpResourceDescriptor.cs @@ -2,11 +2,12 @@ namespace ColaFlow.Modules.Mcp.Contracts.Resources; /// /// Descriptor for an MCP Resource (used in resources/list) +/// Enhanced with metadata for better discovery and documentation /// public class McpResourceDescriptor { /// - /// Resource URI + /// Resource URI (e.g., "colaflow://projects.list") /// public string Uri { get; set; } = string.Empty; @@ -21,7 +22,38 @@ public class McpResourceDescriptor public string Description { get; set; } = string.Empty; /// - /// MIME type + /// MIME type (default: "application/json") /// public string MimeType { get; set; } = "application/json"; + + /// + /// Resource category for organization (e.g., "Projects", "Issues", "Sprints", "Users") + /// + public string Category { get; set; } = "General"; + + /// + /// Resource version (for future compatibility) + /// + public string Version { get; set; } = "1.0"; + + /// + /// Parameters accepted by this resource (for documentation) + /// Key: parameter name, Value: parameter description + /// + public Dictionary? Parameters { get; set; } + + /// + /// Usage examples (for documentation) + /// + public List? Examples { get; set; } + + /// + /// Tags for additional categorization + /// + public List? Tags { get; set; } + + /// + /// Whether this resource is enabled + /// + public bool IsEnabled { get; set; } = true; } diff --git a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Infrastructure/Extensions/McpServiceExtensions.cs b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Infrastructure/Extensions/McpServiceExtensions.cs index e38af67..a616126 100644 --- a/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Infrastructure/Extensions/McpServiceExtensions.cs +++ b/colaflow-api/src/Modules/Mcp/ColaFlow.Modules.Mcp.Infrastructure/Extensions/McpServiceExtensions.cs @@ -10,16 +10,18 @@ using Microsoft.AspNetCore.Builder; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; namespace ColaFlow.Modules.Mcp.Infrastructure.Extensions; /// /// Extension methods for registering MCP services +/// Enhanced with auto-discovery and dynamic registration /// public static class McpServiceExtensions { /// - /// Registers MCP module services + /// Registers MCP module services with auto-discovery /// public static IServiceCollection AddMcpModule(this IServiceCollection services, IConfiguration configuration) { @@ -39,7 +41,10 @@ public static class McpServiceExtensions // Register resource registry (Singleton - shared across all requests) services.AddSingleton(); - // Register MCP Resources + // Register Resource Discovery Service (Singleton - used at startup) + services.AddSingleton(); + + // Register MCP Resources (Scoped - manual registration for now, auto-discovery at startup) services.AddScoped(); services.AddScoped(); services.AddScoped(); @@ -54,6 +59,7 @@ public static class McpServiceExtensions services.AddScoped(); services.AddScoped(); services.AddScoped(); + services.AddScoped(); // NEW: Health check handler services.AddScoped(); services.AddScoped(); @@ -71,7 +77,7 @@ public static class McpServiceExtensions /// public static IApplicationBuilder UseMcpMiddleware(this IApplicationBuilder app) { - // Initialize resource registry (register all resources) + // Initialize resource registry (register all resources with auto-discovery) InitializeResourceRegistry(app); // 1. Correlation ID middleware (FIRST - needed for all subsequent logging) @@ -94,17 +100,30 @@ public static class McpServiceExtensions /// /// Initialize resource registry by registering all resources + /// Enhanced with auto-discovery using Assembly scanning /// This is called once at startup /// private static void InitializeResourceRegistry(IApplicationBuilder app) { using var scope = app.ApplicationServices.CreateScope(); var registry = scope.ServiceProvider.GetRequiredService(); - var resources = scope.ServiceProvider.GetServices(); + var discoveryService = scope.ServiceProvider.GetRequiredService(); + var loggerFactory = scope.ServiceProvider.GetRequiredService(); + var logger = loggerFactory.CreateLogger("McpResourceRegistry"); + logger.LogInformation("Initializing MCP Resource Registry with auto-discovery..."); + + // Auto-discover and instantiate all resources + var resources = discoveryService.DiscoverAndInstantiateResources(scope.ServiceProvider); + + // Register all discovered resources foreach (var resource in resources) { registry.RegisterResource(resource); } + + var categories = registry.GetCategories(); + logger.LogInformation("MCP Resource Registry initialized: {ResourceCount} resources in {CategoryCount} categories: {Categories}", + resources.Count, categories.Count, string.Join(", ", categories)); } } diff --git a/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Handlers/ResourceHealthCheckHandlerTests.cs b/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Handlers/ResourceHealthCheckHandlerTests.cs new file mode 100644 index 0000000..b2ed227 --- /dev/null +++ b/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Handlers/ResourceHealthCheckHandlerTests.cs @@ -0,0 +1,94 @@ +using ColaFlow.Modules.Mcp.Application.Handlers; +using ColaFlow.Modules.Mcp.Application.Services; +using ColaFlow.Modules.Mcp.Contracts.Resources; +using FluentAssertions; +using Microsoft.Extensions.Logging; +using NSubstitute; +using Xunit; + +namespace ColaFlow.Modules.Mcp.Tests.Handlers; + +public class ResourceHealthCheckHandlerTests +{ + private readonly ILogger _mockLogger; + private readonly IMcpResourceRegistry _mockRegistry; + private readonly ResourceHealthCheckHandler _handler; + + public ResourceHealthCheckHandlerTests() + { + _mockLogger = Substitute.For>(); + _mockRegistry = Substitute.For(); + _handler = new ResourceHealthCheckHandler(_mockLogger, _mockRegistry); + } + + [Fact] + public void MethodName_ShouldBeResourcesHealth() + { + // Assert + _handler.MethodName.Should().Be("resources/health"); + } + + [Fact] + public async Task HandleAsync_WithHealthyResources_ShouldReturnHealthyStatus() + { + // Arrange + var mockResource = Substitute.For(); + mockResource.Uri.Returns("test://resource"); + mockResource.Name.Returns("Test Resource"); + mockResource.Category.Returns("Testing"); + mockResource.GetDescriptor().Returns(new McpResourceDescriptor + { + Uri = "test://resource", + Name = "Test Resource", + Category = "Testing", + IsEnabled = true, + Version = "1.0" + }); + + _mockRegistry.GetAllResources() + .Returns(new List { mockResource }.AsReadOnly()); + + // Act + var result = await _handler.HandleAsync(null, CancellationToken.None); + + // Assert + result.Should().NotBeNull(); + var response = result as dynamic; + ((string)response.status).Should().Be("healthy"); + ((int)response.totalResources).Should().Be(1); + ((int)response.healthyResources).Should().Be(1); + ((int)response.unhealthyResources).Should().Be(0); + } + + [Fact] + public async Task HandleAsync_WithUnhealthyResource_ShouldReturnDegradedStatus() + { + // Arrange + var mockResource = Substitute.For(); + mockResource.Uri.Returns("test://resource"); + mockResource.Name.Returns("Test Resource"); + mockResource.Category.Returns("Testing"); + mockResource.GetDescriptor().Returns(new McpResourceDescriptor + { + Uri = "", // Invalid - empty URI + Name = "Test Resource", + Category = "Testing", + IsEnabled = true, + Version = "1.0" + }); + + _mockRegistry.GetAllResources() + .Returns(new List { mockResource }.AsReadOnly()); + + // Act + var result = await _handler.HandleAsync(null, CancellationToken.None); + + // Assert + result.Should().NotBeNull(); + var response = result as dynamic; + ((string)response.status).Should().Be("degraded"); + ((int)response.totalResources).Should().Be(1); + ((int)response.healthyResources).Should().Be(0); + ((int)response.unhealthyResources).Should().Be(1); + } +} diff --git a/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/McpResourceRegistryTests.cs b/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/McpResourceRegistryTests.cs index 8339ebf..05ef354 100644 --- a/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/McpResourceRegistryTests.cs +++ b/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/McpResourceRegistryTests.cs @@ -128,12 +128,12 @@ public class McpResourceRegistryTests private IMcpResource CreateMockResource(string uri, string name) { var resource = Substitute.For(); - resource.Uri.Returns(uri); - resource.Name.Returns(name); - resource.Description.Returns($"Description for {name}"); - resource.MimeType.Returns("application/json"); + resource.UriReturns(uri); + resource.NameReturns(name); + resource.DescriptionReturns($"Description for {name}"); + resource.MimeTypeReturns("application/json"); resource.GetContentAsync(Arg.Any(), Arg.Any()) - .Returns(new McpResourceContent + Returns(new McpResourceContent { Uri = uri, MimeType = "application/json", @@ -141,4 +141,154 @@ public class McpResourceRegistryTests }); return resource; } + + [Fact] + public void GetCategories_ShouldReturnAllUniqueCategories() + { + // Arrange + var mockLogger = Substitute.For>(); + var registry = new McpResourceRegistry(mockLogger); + + var resource1 = Substitute.For(); + resource1.Setup(r => r.Uri)Returns("test://resource1"); + resource1.Setup(r => r.Name)Returns("Resource 1"); + resource1.Setup(r => r.Category)Returns("Projects"); + + var resource2 = Substitute.For(); + resource2.Setup(r => r.Uri)Returns("test://resource2"); + resource2.Setup(r => r.Name)Returns("Resource 2"); + resource2.Setup(r => r.Category)Returns("Issues"); + + var resource3 = Substitute.For(); + resource3.Setup(r => r.Uri)Returns("test://resource3"); + resource3.Setup(r => r.Name)Returns("Resource 3"); + resource3.Setup(r => r.Category)Returns("Projects"); // Duplicate category + + registry.RegisterResource(resource1.Object); + registry.RegisterResource(resource2.Object); + registry.RegisterResource(resource3.Object); + + // Act + var categories = registry.GetCategories(); + + // Assert + Assert.Equal(2, categories.Count); + Assert.Contains("Projects", categories); + Assert.Contains("Issues", categories); + } + + [Fact] + public void GetResourcesByCategory_ShouldReturnOnlyResourcesInCategory() + { + // Arrange + var mockLogger = Substitute.For>(); + var registry = new McpResourceRegistry(mockLogger); + + var projectResource1 = Substitute.For(); + projectResource1.Setup(r => r.Uri)Returns("test://project1"); + projectResource1.Setup(r => r.Name)Returns("Project 1"); + projectResource1.Setup(r => r.Category)Returns("Projects"); + + var projectResource2 = Substitute.For(); + projectResource2.Setup(r => r.Uri)Returns("test://project2"); + projectResource2.Setup(r => r.Name)Returns("Project 2"); + projectResource2.Setup(r => r.Category)Returns("Projects"); + + var issueResource = Substitute.For(); + issueResource.Setup(r => r.Uri)Returns("test://issue1"); + issueResource.Setup(r => r.Name)Returns("Issue 1"); + issueResource.Setup(r => r.Category)Returns("Issues"); + + registry.RegisterResource(projectResource1.Object); + registry.RegisterResource(projectResource2.Object); + registry.RegisterResource(issueResource.Object); + + // Act + var projectResources = registry.GetResourcesByCategory("Projects"); + + // Assert + Assert.Equal(2, projectResources.Count); + Assert.All(projectResources, r => Assert.Equal("Projects", r.Category)); + } + + [Fact] + public void GetResourcesGroupedByCategory_ShouldGroupCorrectly() + { + // Arrange + var mockLogger = Substitute.For>(); + var registry = new McpResourceRegistry(mockLogger); + + var resource1 = Substitute.For(); + resource1.Setup(r => r.Uri)Returns("test://resource1"); + resource1.Setup(r => r.Name)Returns("Resource 1"); + resource1.Setup(r => r.Category)Returns("Projects"); + + var resource2 = Substitute.For(); + resource2.Setup(r => r.Uri)Returns("test://resource2"); + resource2.Setup(r => r.Name)Returns("Resource 2"); + resource2.Setup(r => r.Category)Returns("Issues"); + + var resource3 = Substitute.For(); + resource3.Setup(r => r.Uri)Returns("test://resource3"); + resource3.Setup(r => r.Name)Returns("Resource 3"); + resource3.Setup(r => r.Category)Returns("Projects"); + + registry.RegisterResource(resource1.Object); + registry.RegisterResource(resource2.Object); + registry.RegisterResource(resource3.Object); + + // Act + var grouped = registry.GetResourcesGroupedByCategory(); + + // Assert + Assert.Equal(2, grouped.Count); + Assert.True(grouped.ContainsKey("Projects")); + Assert.True(grouped.ContainsKey("Issues")); + Assert.Equal(2, grouped["Projects"].Count); + Assert.Single(grouped["Issues"]); + } + + [Fact] + public void GetDescriptor_ShouldIncludeEnhancedMetadata() + { + // Arrange + var mockLogger = Substitute.For>(); + var registry = new McpResourceRegistry(mockLogger); + + var mockResource = Substitute.For(); + mockResource(r => r.Uri)Returns("test://resource"); + mockResource(r => r.Name)Returns("Test Resource"); + mockResource(r => r.Description)Returns("Test description"); + mockResource(r => r.MimeType)Returns("application/json"); + mockResource(r => r.Category)Returns("Testing"); + mockResource(r => r.Version)Returns("1.0"); + mockResource(r => r.GetDescriptor())Returns(new McpResourceDescriptor + { + Uri = "test://resource", + Name = "Test Resource", + Description = "Test description", + MimeType = "application/json", + Category = "Testing", + Version = "1.0", + Parameters = new Dictionary { { "id", "Resource ID" } }, + Examples = new List { "GET test://resource?id=123" }, + Tags = new List { "test", "example" }, + IsEnabled = true + }); + + registry.RegisterResource(mockResource); + + // Act + var descriptors = registry.GetResourceDescriptors(); + + // Assert + Assert.Single(descriptors); + var descriptor = descriptors[0]; + Assert.Equal("Testing", descriptor.Category); + Assert.Equal("1.0", descriptor.Version); + Assert.NotNull(descriptor.Parameters); + Assert.NotNull(descriptor.Examples); + Assert.NotNull(descriptor.Tags); + Assert.True(descriptor.IsEnabled); + } } diff --git a/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/ResourceDiscoveryServiceTests.cs b/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/ResourceDiscoveryServiceTests.cs new file mode 100644 index 0000000..82e6820 --- /dev/null +++ b/colaflow-api/tests/Modules/Mcp/ColaFlow.Modules.Mcp.Tests/Services/ResourceDiscoveryServiceTests.cs @@ -0,0 +1,72 @@ +using ColaFlow.Modules.Mcp.Application.Services; +using ColaFlow.Modules.Mcp.Contracts.Resources; +using FluentAssertions; +using Microsoft.Extensions.Logging; +using NSubstitute; +using Xunit; + +namespace ColaFlow.Modules.Mcp.Tests.Services; + +public class ResourceDiscoveryServiceTests +{ + private readonly IResourceDiscoveryService _discoveryService; + private readonly ILogger _mockLogger; + + public ResourceDiscoveryServiceTests() + { + _mockLogger = Substitute.For>(); + _discoveryService = new ResourceDiscoveryService(_mockLogger); + } + + [Fact] + public void DiscoverResourceTypes_ShouldFindAllResourceImplementations() + { + // Act + var resourceTypes = _discoveryService.DiscoverResourceTypes(); + + // Assert + resourceTypes.Should().NotBeEmpty(); + resourceTypes.Should().AllSatisfy(type => + { + typeof(IMcpResource).IsAssignableFrom(type).Should().BeTrue(); + type.IsInterface.Should().BeFalse(); + type.IsAbstract.Should().BeFalse(); + }); + } + + [Fact] + public void DiscoverResourceTypes_ShouldFindKnownResources() + { + // Act + var resourceTypes = _discoveryService.DiscoverResourceTypes(); + + // Assert - should find at least these known resources + var typeNames = resourceTypes.Select(t => t.Name).ToList(); + typeNames.Should().Contain("ProjectsListResource"); + typeNames.Should().Contain("ProjectsGetResource"); + typeNames.Should().Contain("IssuesSearchResource"); + typeNames.Should().Contain("IssuesGetResource"); + typeNames.Should().Contain("SprintsCurrentResource"); + typeNames.Should().Contain("UsersListResource"); + } + + [Fact] + public void DiscoverResourceTypes_ShouldNotIncludeInterfaces() + { + // Act + var resourceTypes = _discoveryService.DiscoverResourceTypes(); + + // Assert + resourceTypes.Should().NotContain(t => t.IsInterface); + } + + [Fact] + public void DiscoverResourceTypes_ShouldNotIncludeAbstractClasses() + { + // Act + var resourceTypes = _discoveryService.DiscoverResourceTypes(); + + // Assert + resourceTypes.Should().NotContain(t => t.IsAbstract); + } +}