mcp-forge 0.1.5

Generate Rust MCP servers from OpenAPI specs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};
use std::path::{Path, PathBuf};

pub mod r#gen;
pub mod ir;
pub mod spec;

#[derive(Parser)]
#[command(
    name = "mcp-forge",
    version,
    about = "Generate Rust MCP servers from OpenAPI specs"
)]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Subcommand)]
enum Command {
    /// Generate a complete Rust MCP server project from an `OpenAPI` spec
    Generate {
        /// Path to the `OpenAPI` 3.0.3 YAML or JSON spec file
        #[arg(long, short)]
        spec: PathBuf,

        /// Output directory for the generated project
        #[arg(long, short, default_value = ".")]
        output: PathBuf,

        /// Project name override (defaults to spec `info.title`, snake-cased)
        #[arg(long)]
        name: Option<String>,
    },

    /// Parse and display the intermediate representation (for debugging)
    Inspect {
        /// Path to the `OpenAPI` spec file
        #[arg(long, short)]
        spec: PathBuf,
    },
}

fn load_spec(path: &Path) -> Result<ir::ApiSpec> {
    let content = std::fs::read_to_string(path)
        .with_context(|| format!("failed to read spec: {}", path.display()))?;

    let openapi: spec::OpenApiSpec = if path.extension().is_some_and(|e| e == "json") {
        serde_json::from_str(&content)?
    } else {
        serde_yaml_ng::from_str(&content)?
    };

    Ok(ir::ApiSpec::from_openapi(&openapi))
}

#[tokio::main]
async fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
        )
        .init();

    let cli = Cli::parse();

    match cli.command {
        Command::Generate { spec, output, name } => {
            let mut api = load_spec(&spec)?;

            if let Some(n) = name {
                api.name = n;
            }

            r#gen::generate(&api, &output).context("failed to generate project")?;

            tracing::info!(
                "Generated MCP server '{}' ({} operations, {} types) → {}",
                api.name,
                api.operations.len(),
                api.types.len(),
                output.display()
            );
        }

        Command::Inspect { spec } => {
            let api = load_spec(&spec)?;

            println!("Name: {}", api.name);
            println!("Version: {}", api.version);
            println!("Base URL: {}", api.base_url.as_deref().unwrap_or("-"));
            println!("Auth: {}", api.auth);
            println!("\nOperations ({}):", api.operations.len());
            for op in &api.operations {
                println!(
                    "  {} {} → {} ({})",
                    op.method,
                    op.path,
                    op.id,
                    op.summary.as_deref().unwrap_or("-")
                );
            }
            println!("\nTypes ({}):", api.types.len());
            for t in &api.types {
                if t.is_enum {
                    println!(
                        "  enum {} ({} variants)",
                        t.rust_name,
                        t.enum_variants.len()
                    );
                } else {
                    println!("  struct {} ({} fields)", t.rust_name, t.fields.len());
                }
            }
        }
    }

    Ok(())
}