feat(api): implement NuGet package tools and integration tests

Signed-off-by: SebastienDegodez <sebastien.degodez@gmail.com>

Author: SebastienDegodez

README.md

@@ -1,33 +1,68 @@
-# McpPack MCP Server (.NET)
+# MCP.Pack 🚀
 
-This project is a Model Context Protocol (MCP) server built with .NET, following Clean Architecture and Domain-Driven Design (DDD) principles.
+A modern .NET server for Model Context Protocol (MCP) and NuGet package management 📦.
+Built with Clean Architecture 🏗️ and Domain-Driven Design (DDD) 🧠, supporting AOT compilation ⚡ and comprehensive automated testing 🧪.
 
-## Structure
-- **McpPack.Domain**: Domain logic, aggregates, entities, value objects, repositories, domain events
-- **McpPack.Application**: Application services, use cases, interfaces
-- **McpPack.Infrastructure**: Infrastructure implementations (e.g., data access, external services)
-- **McpPack.Api**: ASP.NET Core Web API (entry point)
+---
 
-## Getting Started
+## ✨ Features
+- 🔍 Discover and search NuGet packages via the Model Context Protocol (MCP)
+- 📑 Retrieve rich package metadata for any NuGet feed
+- 🧩 Designed for extensibility and integration in modern .NET ecosystems
 
-### Prerequisites
-- [.NET 8 SDK](https://dotnet.microsoft.com/download)
+## 🛠️ Technical Highlights
+- 🏗️ **Clean Architecture**: strict separation of Domain, Application, Infrastructure, and API layers
+- ⚡ **AOT (Ahead-Of-Time) compilation**: fast startup, low memory usage
+- 🧪 **Comprehensive automated tests**: unit, integration, and architecture validation
+- 💎 **Modern .NET 9**: minimal APIs, dependency injection, async/await everywhere
 
-### Build
+## 🗂️ Project Structure
+
+```
+McpPack.sln
+src/
+  McpPack.Domain/         # Domain logic, aggregates, value objects, repositories
+  McpPack.Application/    # Use cases, service interfaces
+  McpPack.Infrastructure/ # Implementations for repositories, external services
+  McpPack.Api/            # API endpoints, orchestration
+
+tests/
+  McpPack.UnitTests/      # Unit tests for Domain & Application
+  McpPack.IntegrationTests/ # Integration & architecture tests
+```
+
+## 🚀 Getting Started
+
+### 🧰 Prerequisites
+- 🟣 [.NET 9 SDK](https://dotnet.microsoft.com/download)
+- 📊 (Optional) [dotnet-reportgenerator-globaltool](https://github.com/danielpalme/ReportGenerator) for coverage reports
+
+### 🏃‍♂️ Build & Run
 ```sh
 dotnet build
+dotnet run --project src/McpPack.Api
 ```
 
-### Run
+### 🧪 Test
 ```sh
-dotnet run --project McpPack.Api
+dotnet test
 ```
 
-### Debug
-- Open the solution in VS Code or Visual Studio
-- Set breakpoints in any project
-- Start debugging (F5)
+## 🏛️ Architecture Principles
+- 🧠 **Domain**: no dependencies, pure business logic
+- 🎯 **Application**: orchestrates use cases, depends only on Domain
+- 🏗️ **Infrastructure**: implements interfaces, depends on Application & Domain
+- 🌐 **API**: exposes endpoints, depends only on Infrastructure
+- 🧪 **Tests**: separated by type (unit/integration/architecture)
+
+## 🤝 Contributing
+- 📝 Follow [Conventional Commits](https://www.conventionalcommits.org/)
+- 🧪 Write tests for all new features and bugfixes
+- 🧹 Keep code clean and robust
+
+## 📄 License
+MIT
+
+---
 
-## Notes
-- Follow DDD and Clean Architecture best practices for all new code.
-- See `.github/copilot-instructions.md` for Copilot guidance.
+> Because good enough is never enough. 😎

src/McpPack.Api/McpPack.Api.csproj

@@ -1,12 +1,17 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <ItemGroup>
     <ProjectReference Include="..\McpPack.Infrastructure\McpPack.Infrastructure.csproj" />
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.6" />
-    <PackageReference Include="ModelContextProtocol" Version="0.2.0-preview.3" />
+    <PackageReference Include="ModelContextProtocol" Version="0.3.0-preview.1" />
+    <PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.3.0-preview.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Properties/" />
   </ItemGroup>
 
   <PropertyGroup>
@@ -15,5 +20,11 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
-
+  
+  <PropertyGroup>
+    <!-- Enables Native AOT compilation during publish-->
+    <PublishAot>true</PublishAot>
+    <!--Favor the size of the executable instead of other performance -->
+    <OptimizationPreference>Size</OptimizationPreference>
+  </PropertyGroup>
 </Project>

src/McpPack.Api/McpPackJsonContext.cs

@@ -0,0 +1,13 @@
+using McpPack.Domain.PackageAggregate;
+using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
+
+namespace McpPack.Api;
+
+[ExcludeFromCodeCoverage(
+    Justification = "This is a generated file for JSON serialization context, no manual changes are expected.")]
+[JsonSerializable(typeof(IEnumerable<PackageMetadata>))]
+[JsonSerializable(typeof(PackageMetadata))]
+public partial class McpPackJsonContext : JsonSerializerContext
+{
+}

src/McpPack.Api/NugetPackageTools.cs

@@ -0,0 +1,58 @@
+using System.ComponentModel;
+using McpPack.Application.RetrievePackage;
+using McpPack.Domain.PackageAggregate;
+using ModelContextProtocol.Server;
+
+namespace McpPack.Api;
+
+/// <summary>
+/// Provides tools for managing NuGet packages.
+/// This class is registered as a server tool in the ModelContextProtocol.
+/// It allows clients to retrieve package metadata, such as the latest version of a NuGet package.
+/// </summary>
+/// <remarks>
+/// This class is part of the McpPack.Api assembly, which serves as the API layer
+/// in the Clean Architecture structure of the McpPack application.
+/// It interacts with the Application layer to perform operations related to NuGet packages.
+/// The RetrieveNugetPackageVersionAsync method is exposed as a server tool that can be called
+/// by clients to retrieve the latest version of a specified NuGet package.
+/// </remarks>
+/// <example>
+/// Example usage:
+/// ```csharp
+/// var packageTools = new PackageTools(RetrievePackageMetadataUseCase);
+/// var latestVersion = await packageTools.RetrieveNugetPackageVersionAsync("Newtonsoft.Json");
+/// foreach (var version in latestVersion)
+/// {
+///     Console.WriteLine($"Package: {version.Id}, Version: {version.Version}");
+/// }
+/// ```
+/// </example>
+/// <seealso cref="RetrievePackageMetadataUseCase"/>
+[McpServerToolType]
+public sealed class NugetPackageTools
+{
+    public const string RetrieveNugetPackageVersion = "RetrieveNugetPackageVersion";
+
+    private readonly RetrievePackageMetadataUseCase _retrievePackageMetadataUseCase;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NugetPackageTools"/> class.
+    /// </summary>
+    /// <param name="retrievePackageMetadataUseCase">The use case for retrieving package metadata.</param>
+    public NugetPackageTools(RetrievePackageMetadataUseCase retrievePackageMetadataUseCase)
+    {
+        _retrievePackageMetadataUseCase = retrievePackageMetadataUseCase;
+    }
+
+    /// <summary>
+    /// Gets the latest version of a NuGet package from nuget server.
+    /// </summary>
+    [McpServerTool(Name = RetrieveNugetPackageVersion), Description("Retrieve the latest version of a NuGet package from nuget server.")]
+    public async Task<IEnumerable<PackageMetadata>> RetrieveNugetPackageVersionAsync(
+        [Description("The NuGet package name")] string packageName)
+    {
+        var metadata = await _retrievePackageMetadataUseCase.ExecuteAsync(packageName);
+        return metadata;
+    }
+}

src/McpPack.Api/Program.cs

@@ -0,0 +1,34 @@
+using McpPack.Api;
+using McpPack.Application.RetrievePackage;
+using McpPack.Infrastructure.DependencyInjection;
+
+var builder = WebApplication.CreateSlimBuilder(args);
+builder.Logging.AddConsole(consoleLogOptions =>
+{
+    // Configure all logs to go to stderr
+    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
+});
+
+// Register application use cases
+builder.Services.AddTransient<RetrievePackageMetadataUseCase>();
+
+// Register all infrastructure services through Infrastructure layer
+// Configure NugetServiceOptions from configuration (appsettings.json or environment variables)
+builder.Services.AddInfrastructureServices(builder.Configuration);
+
+builder.Services
+    .AddMcpServer()
+    .WithHttpTransport()
+    .WithTools<NugetPackageTools>(serializerOptions: McpPackJsonContext.Default.Options);
+
+var application = builder.Build();
+
+application.MapMcp();
+
+await application.RunAsync();
+
+public partial class Program
+{
+    // This partial class is used to allow the HostBuilder to be extended in other files if needed.
+    // It can be useful for adding additional configuration or services in a modular way.
+}

src/McpPack.Api/Properties/launchSettings.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "McpPack.Api (http)": {
+      "commandName": "Project",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:5000",
+      "dotnetRunMessages": true
+    },
+    "McpPack.Api (https)": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "https://localhost:5001;http://localhost:5000",
+      "dotnetRunMessages": true
+    },
+  }
+}

src/McpPack.Application/RetrievePackage/RetrievePackageMetadataUseCase.cs

@@ -0,0 +1,23 @@
+using McpPack.Domain.PackageAggregate;
+
+namespace McpPack.Application.RetrievePackage;
+
+public sealed class RetrievePackageMetadataUseCase
+{
+    private readonly INugetService _nugetService;
+
+    public RetrievePackageMetadataUseCase(INugetService nugetService)
+    {
+        _nugetService = nugetService ?? throw new ArgumentNullException(nameof(nugetService));
+    }
+
+    public async Task<IReadOnlyList<PackageMetadata>> ExecuteAsync(
+        string query,
+        CancellationToken cancellationToken = default)
+    {
+        if (string.IsNullOrWhiteSpace(query))
+            throw new ArgumentException("Query cannot be null or empty", nameof(query));
+
+        return await _nugetService.SearchPackagesAsync(query, cancellationToken);
+    }
+}

src/McpPack.Domain/PackageAggregate/AvailablePackageVersions.cs

@@ -0,0 +1,30 @@
+using System.Collections;
+
+namespace McpPack.Domain.PackageAggregate;
+
+public sealed class AvailablePackageVersions
+{
+    private readonly IReadOnlyList<PackageVersion> _versions;
+
+    private AvailablePackageVersions(IEnumerable<PackageVersion> versions)
+    {
+        ArgumentNullException.ThrowIfNull(versions);
+        var versionList = versions.ToList();
+        if (versionList.Count == 0)
+        {
+            throw new ArgumentException("At least one version must be provided", nameof(versions));
+        }
+
+        _versions = versionList;
+    }
+
+    public static AvailablePackageVersions Create(IEnumerable<PackageVersion> versions) => new(versions);
+
+    public bool Any() => _versions.Count > 0;
+
+    public PackageVersion GetLatest()
+    {
+        return _versions.First();
+    }
+
+}

src/McpPack.Domain/PackageAggregate/INugetService.cs

@@ -0,0 +1,6 @@
+namespace McpPack.Domain.PackageAggregate;
+
+public interface INugetService
+{
+    Task<IReadOnlyList<PackageMetadata>> SearchPackagesAsync(string query, CancellationToken cancellationToken = default);
+}

src/McpPack.Domain/PackageAggregate/PackageMetadata.cs

@@ -0,0 +1,35 @@
+namespace McpPack.Domain.PackageAggregate;
+
+public sealed class PackageMetadata
+{
+    public string Title { get; }
+    public Uri? ReadmeUri { get; }
+    public AvailablePackageVersions Versions { get; }
+
+    private PackageMetadata(string title, Uri? readmeUri, AvailablePackageVersions versions)
+    {
+        if (string.IsNullOrWhiteSpace(title))
+        {
+            throw new ArgumentException("Package title cannot be null or empty", nameof(title));
+        }
+
+        Title = title;
+        ReadmeUri = readmeUri;
+        Versions = versions ?? throw new ArgumentNullException(nameof(versions));
+    }
+
+    public static PackageMetadata Create(string title, Uri? readmeUri, AvailablePackageVersions versions)
+    {
+        return new PackageMetadata(title, readmeUri, versions);
+    }
+
+    public bool HasVersions()
+    {
+        return Versions.Any();
+    }
+
+    public PackageVersion? GetLatestVersion()
+    {
+        return Versions.GetLatest();
+    }
+}