Model Context Protocol (MCP) implementation ; increase coverage

Author: SamuelMarks

.pre-commit-config.yaml

@@ -66,7 +66,7 @@ repos:
 
       - id: update-coverage
         name: Update Coverage Badges
-        entry: python scripts/update_coverage.py
-        language: python
+        entry: python3 scripts/update_coverage.py
+        language: system
         pass_filenames: false
         always_run: true

README.md

@@ -3,7 +3,7 @@ cdd-rust
 [![License](https://img.shields.io/badge/license-Apache--2.0%20OR%20MIT-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![interactive WASM web demo](https://img.shields.io/badge/interactive-WASM_web_demo-blue.svg)](https://offscale.io/wasm_web_demo)
 [![CI](https://github.com/offscale/cdd-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/offscale/cdd-rust/actions)
-[![Test Coverage](https://img.shields.io/badge/test_coverage-77.24%25-yellow.svg)](#)
+[![Test Coverage](https://img.shields.io/badge/test_coverage-100.00%25-brightgreen.svg)](#)
 [![Doc Coverage](https://img.shields.io/badge/doc_coverage-100.00%25-brightgreen.svg)](#)
 
 ----
@@ -83,34 +83,42 @@ The `cdd-rust` compiler leverages a unified architecture to support various face
 
 `cdd-rust` supports extensive backwards compatibility features:
 - **Legacy Swagger 2.0 Support:** Natively parses and processes legacy `swagger: "2.0"` specifications in addition to OpenAPI 3.x, ensuring seamless backwards compatibility and bridging older APIs into the modern Rust ecosystem.
+- **Model Context Protocol (MCP):** Exposes CLI commands as an MCP server over STDIO, allowing seamless integration with AI agents and other MCP clients.
 
 ## CLI Options
 
 ```text
 CDD Toolchain CLI
 
+Language-Specific Commands:
+  sync        Synchronize DB schema to Rust models and OpenAPI-ready structs.
+  test-gen    Generates integration tests based on OpenAPI contracts.
+  scaffold    Scaffolds handler functions from OpenAPI Routes.
+  schema-gen  Generates a JSON Schema from a Rust struct or enum.
+
 Usage: cdd-rust [OPTIONS] <COMMAND>
 
 Commands:
   sync            Synchronize DB schema to Rust models and OpenAPI-ready structs
   test-gen        Generates integration tests based on OpenAPI contracts
   scaffold        Scaffolds handler functions from OpenAPI Routes
   schema-gen      Generates a JSON Schema from a Rust struct or enum
-  to_docs_json    Generate JSON documentation with code snippets for an OpenAPI specification.
-  from_openapi    Generate code from an OpenAPI specification.
-  to_openapi      Generate an OpenAPI specification from source code.
-  serve_json_rpc  Expose CLI interface as a JSON-RPC server.
+  to_docs_json    Generate JSON documentation with code snippets for an OpenAPI specification
+  from_openapi    Generate code from an OpenAPI specification
+  to_openapi      Generate an OpenAPI specification from source code
+  serve_json_rpc  Expose CLI interface as a JSON-RPC server
+  mcp             Expose CLI interface as an MCP server over STDIO
   help            Print this message or the help of the given subcommand(s)
 
 Options:
   -t, --target <TARGET>
           Target mode (server or client)
 
           Possible values:
-          - server-actix: Generate Actix Web server scaffolding
-          - server-axum:  Generate Axum server scaffolding
-          - client:       Generate Reqwest client scaffolding
-          - cli:          Generate Clap CLI scaffolding
+          - server-actix:    Actix Web Server
+          - server-axum:     Axum Server
+          - client-reqwest:  Reqwest Client
+          - client-internal: Internal
           
           [env: CDD_TARGET=]
           [default: server-actix]

cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cdd-cli"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2021"
 
 [[bin]]

cli/src/from_openapi.rs

@@ -36,6 +36,9 @@ pub enum FromOpenApiCommands {
     /// Generate a Client SDK
     #[clap(name = "to_sdk")]
     Sdk(GenerateArgs),
+    /// Generate an MCP Programmatic Tool Adapter SDK
+    #[clap(name = "to_sdk_mcp")]
+    SdkMcp(GenerateArgs),
     /// Generate Server scaffolding
     #[clap(name = "to_server")]
     Server {
@@ -121,6 +124,10 @@ pub fn execute(args: &FromOpenApiArgs) -> AppResult<()> {
             println!("Generating SDK...");
             run_generation(gen_args, &ReqwestStrategy)?;
         }
+        FromOpenApiCommands::SdkMcp(gen_args) => {
+            println!("Generating MCP SDK...");
+            run_generation(gen_args, &cdd_core::strategies::McpClientStrategy)?;
+        }
         FromOpenApiCommands::Server {
             args: gen_args,
             framework,
@@ -432,6 +439,19 @@ components:
         };
         assert!(execute(&args).is_ok());
 
+        // Test SdkMcp
+        let args = FromOpenApiArgs {
+            command: FromOpenApiCommands::SdkMcp(GenerateArgs {
+                input: Some(input_file.clone()),
+                input_dir: None,
+                output_dir: Some(dir.path().join("out_mcp")),
+                no_github_actions: false,
+                no_installable_package: false,
+                tests: false,
+            }),
+        };
+        assert!(execute(&args).is_ok());
+
         // Test Server with ActixWeb
         let args = FromOpenApiArgs {
             command: FromOpenApiCommands::Server {
@@ -512,6 +532,15 @@ components:
         let _ = run_generation(&args, &cdd_core::strategies::ActixStrategy);
         Ok(())
     }
+    #[test]
+    fn test_generate_from_openapi_unknown_subcommand() {
+        let config = FromOpenApiConfig {
+            subcommand: "unknown_cmd".to_string(),
+            ..Default::default()
+        };
+        let result = generate_from_openapi(&config);
+        assert!(result.is_err());
+    }
 }
 
 /// Configuration for `from_openapi` programmatic API
@@ -541,6 +570,7 @@ pub fn generate_from_openapi(config: &FromOpenApiConfig) -> AppResult<()> {
     match config.subcommand.as_str() {
         "to_sdk_cli" => run_generation(&gen_args, &ClapCliStrategy),
         "to_sdk" => run_generation(&gen_args, &ReqwestStrategy),
+        "to_sdk_mcp" => run_generation(&gen_args, &cdd_core::strategies::McpClientStrategy),
         "to_server" => match config.framework {
             ServerFramework::ActixWeb => {
                 run_generation(&gen_args, &cdd_core::strategies::ActixStrategy)

cli/src/lib.rs

@@ -3,6 +3,7 @@
 
 pub mod from_openapi;
 pub mod generator;
+pub mod mcp;
 pub mod scaffold;
 pub mod schema_gen;
 #[cfg(all(feature = "server", not(target_os = "wasi")))]

cli/src/main.rs

@@ -93,6 +93,9 @@ enum Commands {
     /// Fallback for missing server feature
     #[cfg(any(not(feature = "server"), target_os = "wasi"))]
     ServeJsonRpc,
+    /// Expose CLI interface as an MCP server over STDIO.
+    #[clap(name = "mcp")]
+    Mcp(cdd_cli::mcp::McpArgs),
 }
 
 /// The main entry point of the CLI application.
@@ -146,6 +149,9 @@ fn main() -> AppResult<()> {
                 "Server feature is not compiled or not supported on this platform".to_string(),
             ));
         }
+        Commands::Mcp(args) => {
+            cdd_cli::mcp::serve_mcp(args)?;
+        }
     }
 
     Ok(())