mcp-new 0.1.0 → 1.1.0

package/README.md

@@ -1,17 +1,17 @@
-# mcp-new
+# mcp-generator
 
 > CLI generator for MCP servers in seconds. Like `create-react-app`, but for MCP.
 
 ## Quick Start
 
 ```bash
-npx mcp-new my-server
+npx mcp-generator my-server
 ```
 
 ## Features
 
 - **Interactive wizard** — create MCP server through step-by-step prompts
-- **TypeScript and Python** — support for both languages
+- **Multi-language support** — TypeScript, Python, Go, and Rust
 - **OpenAPI generation** — auto-create tools from OpenAPI/Swagger specification
 - **AI generation** — create tools from text description using Claude
 - **Ready-to-use templates** — working code with examples out of the box
@@ -19,13 +19,13 @@ npx mcp-new my-server
 ## Installation
 
 ```bash
-npm install -g mcp-new
+npm install -g mcp-generator
 ```
 
 Or use directly via npx:
 
 ```bash
-npx mcp-new my-server
+npx mcp-generator my-server
 ```
 
 ## Usage
@@ -33,7 +33,7 @@ npx mcp-new my-server
 ### Basic creation
 
 ```bash
-npx mcp-new my-weather-api
+npx mcp-generator my-weather-api
 
 # Answer the questions:
 # ? Project name: my-weather-api
@@ -51,22 +51,28 @@ npm run dev
 
 ```bash
 # TypeScript project (skips language prompt)
-npx mcp-new my-server -t
+npx mcp-generator my-server -t
 
 # Python project (skips language prompt)
-npx mcp-new my-server -p
+npx mcp-generator my-server -p
+
+# Go project (skips language prompt)
+npx mcp-generator my-server -g
+
+# Rust project (skips language prompt)
+npx mcp-generator my-server -r
 
 # Skip dependency installation
-npx mcp-new my-server --skip-install
+npx mcp-generator my-server --skip-install
 
 # Use default values
-npx mcp-new my-server -y
+npx mcp-generator my-server -y
 ```
 
 ### From OpenAPI specification
 
 ```bash
-npx mcp-new stripe-mcp --from-openapi ./stripe-api.yaml
+npx mcp-generator stripe-mcp --from-openapi ./stripe-api.yaml
 
 # CLI will show found endpoints and let you select the ones you need
 ```
@@ -74,7 +80,7 @@ npx mcp-new stripe-mcp --from-openapi ./stripe-api.yaml
 ### From text description (AI)
 
 ```bash
-npx mcp-new notion-mcp --from-prompt
+npx mcp-generator notion-mcp --from-prompt
 
 # Describe your API in the editor
 # Claude will generate tools automatically
@@ -86,23 +92,23 @@ Requires `ANTHROPIC_API_KEY` environment variable.
 
 ```bash
 cd my-existing-project
-npx mcp-new init
+npx mcp-generator init
 ```
 
 ### Add new tool
 
 ```bash
 cd my-mcp-server
-npx mcp-new add-tool
+npx mcp-generator add-tool
 ```
 
 ## CLI Commands
 
 | Command | Description |
 |---------|-------------|
-| `mcp-new <name>` | Create new MCP server |
-| `mcp-new init` | Initialize MCP in current directory |
-| `mcp-new add-tool` | Add tool to existing server |
+| `mcp-generator <name>` | Create new MCP server |
+| `mcp-generator init` | Initialize MCP in current directory |
+| `mcp-generator add-tool` | Add tool to existing server |
 
 ## Options
 
@@ -110,6 +116,8 @@ npx mcp-new add-tool
 |------|-------------|
 | `-t, --typescript` | Use TypeScript (skips language prompt) |
 | `-p, --python` | Use Python (skips language prompt) |
+| `-g, --go` | Use Go (skips language prompt) |
+| `-r, --rust` | Use Rust (skips language prompt) |
 | `--skip-install` | Skip dependency installation |
 | `--from-openapi <path>` | Create from OpenAPI specification |
 | `--from-prompt` | Create via AI from description |
@@ -149,12 +157,41 @@ my-server/
         └── example_tool.py
 ```
 
+### Go
+
+```
+my-server/
+├── go.mod
+├── README.md
+├── .gitignore
+├── .env.example
+├── cmd/
+│   └── server/
+│       └── main.go       # Main server file
+└── internal/
+    └── tools/
+        └── example.go
+```
+
+### Rust
+
+```
+my-server/
+├── Cargo.toml
+├── README.md
+├── .gitignore
+├── .env.example
+└── src/
+    ├── main.rs           # Main server file
+    └── tools.rs
+```
+
 ## Development
 
 ```bash
 # Clone repository
-git clone https://github.com/d1maash/mcp-new.git
-cd mcp-new
+git clone https://github.com/d1maash/mcp-generator.git
+cd mcp-generator
 
 # Install dependencies
 npm install
@@ -170,7 +207,7 @@ npm test
 
 # Local CLI testing
 npm link
-mcp-new test-project
+mcp-generator test-project
 ```
 
 ## Links
@@ -178,6 +215,8 @@ mcp-new test-project
 - [MCP Specification](https://spec.modelcontextprotocol.io/)
 - [MCP TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk)
 - [MCP Python SDK](https://github.com/modelcontextprotocol/python-sdk)
+- [MCP Go SDK](https://github.com/mark3labs/mcp-go)
+- [MCP Rust SDK](https://github.com/modelcontextprotocol/rust-sdk)
 
 ## License
 

package/dist/{chunk-QRUHMGU5.js → chunk-K3TOM22I.js}

@@ -100,7 +100,9 @@ async function promptLanguage() {
       message: "Select language:",
       choices: [
         { name: "TypeScript", value: "typescript" },
-        { name: "Python", value: "python" }
+        { name: "Python", value: "python" },
+        { name: "Go", value: "go" },
+        { name: "Rust", value: "rust" }
       ],
       default: "typescript"
     }
@@ -639,11 +641,19 @@ var BaseGenerator = class {
       logger.info("Skipping dependency installation (--skip-install)");
       return;
     }
-    const isTypescript = this.config.language === "typescript";
-    if (isTypescript) {
-      await this.installNodeDependencies();
-    } else {
-      await this.installPythonDependencies();
+    switch (this.config.language) {
+      case "typescript":
+        await this.installNodeDependencies();
+        break;
+      case "python":
+        await this.installPythonDependencies();
+        break;
+      case "go":
+        await this.installGoDependencies();
+        break;
+      case "rust":
+        await this.installRustDependencies();
+        break;
     }
   }
   async installNodeDependencies() {
@@ -676,9 +686,49 @@ var BaseGenerator = class {
       "Failed to install dependencies"
     );
   }
+  async installGoDependencies() {
+    const hasGo = await this.checkCommand("go");
+    if (!hasGo) {
+      logger.warning("Go not found. Please install dependencies manually:");
+      logger.code("go mod download");
+      return;
+    }
+    await withSpinner(
+      "Installing Go dependencies...",
+      async () => {
+        await execa2("go", ["mod", "download"], {
+          cwd: this.outputDir
+        });
+        await execa2("go", ["mod", "tidy"], {
+          cwd: this.outputDir
+        });
+      },
+      "Dependencies installed",
+      "Failed to install dependencies"
+    );
+  }
+  async installRustDependencies() {
+    const hasCargo = await this.checkCommand("cargo");
+    if (!hasCargo) {
+      logger.warning("Cargo not found. Please install dependencies manually:");
+      logger.code("cargo build");
+      return;
+    }
+    await withSpinner(
+      "Building Rust project...",
+      async () => {
+        await execa2("cargo", ["build"], {
+          cwd: this.outputDir
+        });
+      },
+      "Project built successfully",
+      "Failed to build project"
+    );
+  }
   async checkCommand(command) {
     try {
-      await execa2("which", [command]);
+      const checkCmd = process.platform === "win32" ? "where" : "which";
+      await execa2(checkCmd, [command]);
       return true;
     } catch {
       return false;
@@ -1165,7 +1215,7 @@ async function createCommand(projectName, options) {
 }
 async function handleWizardGeneration(projectName, options) {
   let config;
-  const presetLanguage = options.typescript ? "typescript" : options.python ? "python" : void 0;
+  const presetLanguage = options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0;
   if (options.yes) {
     config = await runQuickWizard(projectName, presetLanguage);
   } else {
@@ -1193,14 +1243,14 @@ async function handleOpenAPIGeneration(projectName, options) {
   const name = projectName || path4.basename(specPath, path4.extname(specPath)) + "-mcp";
   await generateFromOpenAPI(specPath, {
     name,
-    language: options.typescript ? "typescript" : options.python ? "python" : void 0,
+    language: options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0,
     skipInstall: options.skipInstall
   });
 }
 async function handlePromptGeneration(projectName, options) {
   await generateFromPrompt({
     name: projectName,
-    language: options.typescript ? "typescript" : options.python ? "python" : void 0,
+    language: options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0,
     skipInstall: options.skipInstall
   });
 }
@@ -1214,7 +1264,9 @@ async function initCommand(options) {
     const dirName = path5.basename(currentDir);
     const hasPackageJson = await exists(path5.join(currentDir, "package.json"));
     const hasPyproject = await exists(path5.join(currentDir, "pyproject.toml"));
-    if ((hasPackageJson || hasPyproject) && !options.force) {
+    const hasGoMod = await exists(path5.join(currentDir, "go.mod"));
+    const hasCargoToml = await exists(path5.join(currentDir, "Cargo.toml"));
+    if ((hasPackageJson || hasPyproject || hasGoMod || hasCargoToml) && !options.force) {
       const { proceed } = await inquirer8.prompt([
         {
           type: "confirm",
@@ -1233,12 +1285,22 @@ async function initCommand(options) {
       language = "typescript";
     } else if (options.python) {
       language = "python";
+    } else if (options.go) {
+      language = "go";
+    } else if (options.rust) {
+      language = "rust";
     } else if (hasPackageJson) {
       language = "typescript";
       logger.info("Detected existing Node.js project, using TypeScript");
     } else if (hasPyproject) {
       language = "python";
       logger.info("Detected existing Python project");
+    } else if (hasGoMod) {
+      language = "go";
+      logger.info("Detected existing Go project");
+    } else if (hasCargoToml) {
+      language = "rust";
+      logger.info("Detected existing Rust project");
     } else {
       language = await promptLanguage();
     }
@@ -1283,7 +1345,9 @@ async function addToolCommand(options) {
     const currentDir = process.cwd();
     const isTypeScript = await exists(path6.join(currentDir, "package.json"));
     const isPython = await exists(path6.join(currentDir, "pyproject.toml"));
-    if (!isTypeScript && !isPython) {
+    const isGo = await exists(path6.join(currentDir, "go.mod"));
+    const isRust = await exists(path6.join(currentDir, "Cargo.toml"));
+    if (!isTypeScript && !isPython && !isGo && !isRust) {
       logger.error("No MCP server project found in current directory.");
       logger.info("Run this command from the root of your MCP server project.");
       process.exit(1);
@@ -1301,8 +1365,12 @@ async function addToolCommand(options) {
     }
     if (isTypeScript) {
       await addToolToTypeScript(currentDir, tool);
-    } else {
+    } else if (isPython) {
       await addToolToPython(currentDir, tool);
+    } else if (isGo) {
+      await addToolToGo(currentDir, tool);
+    } else if (isRust) {
+      await addToolToRust(currentDir, tool);
     }
     logger.success(`Tool "${tool.name}" added successfully!`);
     logger.info("Remember to implement the tool logic in the generated file.");
@@ -1479,6 +1547,173 @@ function mapTypeToPython(type) {
       return "str";
   }
 }
+async function addToolToGo(projectDir, tool) {
+  const toolsDir = path6.join(projectDir, "internal", "tools");
+  const toolFileName = `${tool.name}.go`;
+  const toolFilePath = path6.join(toolsDir, toolFileName);
+  if (await exists(toolFilePath)) {
+    logger.error(`Tool file already exists: ${toolFilePath}`);
+    process.exit(1);
+  }
+  const content = generateGoToolFile(tool);
+  await writeFile(toolFilePath, content);
+  logger.info(`Created: internal/tools/${toolFileName}`);
+  logger.blank();
+  logger.info("Next steps:");
+  logger.list([
+    `Implement the tool logic in internal/tools/${toolFileName}`,
+    "Import and register the tool in cmd/server/main.go"
+  ]);
+}
+async function addToolToRust(projectDir, tool) {
+  const srcDir = path6.join(projectDir, "src");
+  const toolFileName = `${tool.name}.rs`;
+  const toolFilePath = path6.join(srcDir, toolFileName);
+  if (await exists(toolFilePath)) {
+    logger.error(`Tool file already exists: ${toolFilePath}`);
+    process.exit(1);
+  }
+  const content = generateRustToolFile(tool);
+  await writeFile(toolFilePath, content);
+  logger.info(`Created: src/${toolFileName}`);
+  logger.blank();
+  logger.info("Next steps:");
+  logger.list([
+    `Implement the tool logic in src/${toolFileName}`,
+    `Add "mod ${tool.name};" to src/main.rs`,
+    "Register the tool in the server builder"
+  ]);
+}
+function generateGoToolFile(tool) {
+  const structFields = tool.parameters.map((p) => `	${toPascalCase(p.name)} ${mapTypeToGo(p.type)} \`json:"${p.name}"\``).join("\n");
+  return `package tools
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// ${toPascalCase(tool.name)}Input represents the input for the ${tool.name} tool
+type ${toPascalCase(tool.name)}Input struct {
+${structFields || "	// No parameters"}
+}
+
+// ${toPascalCase(tool.name)}Tool creates the ${tool.name} tool definition
+func ${toPascalCase(tool.name)}Tool() mcp.Tool {
+	return mcp.NewTool("${tool.name}",
+		mcp.WithDescription("${tool.description}"),
+${tool.parameters.map((p) => {
+    const mcpType = p.type === "number" ? "WithNumber" : p.type === "boolean" ? "WithBoolean" : "WithString";
+    return `		mcp.${mcpType}("${p.name}",
+${p.required ? "			mcp.Required(),\n" : ""}			mcp.Description("${p.description}"),
+		),`;
+  }).join("\n")}
+	)
+}
+
+// ${toPascalCase(tool.name)}Handler handles the ${tool.name} tool execution
+func ${toPascalCase(tool.name)}Handler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// TODO: Implement ${tool.name} logic
+${tool.parameters.map((p) => {
+    const goType = mapTypeToGo(p.type);
+    if (goType === "float64") {
+      return `	${p.name}, _ := request.Params.Arguments["${p.name}"].(float64)`;
+    } else if (goType === "bool") {
+      return `	${p.name}, _ := request.Params.Arguments["${p.name}"].(bool)`;
+    } else {
+      return `	${p.name}, _ := request.Params.Arguments["${p.name}"].(string)`;
+    }
+  }).join("\n")}
+
+	return mcp.NewToolResultText(fmt.Sprintf("${tool.name} called with: %v", request.Params.Arguments)), nil
+}
+`;
+}
+function generateRustToolFile(tool) {
+  const structFields = tool.parameters.map((p) => `    pub ${p.name}: ${mapTypeToRust(p.type)},`).join("\n");
+  const required = tool.parameters.filter((p) => p.required).map((p) => `"${p.name}".to_string()`).join(", ");
+  return `use rmcp::{
+    model::{CallToolResult, Content, Tool, ToolInputSchema},
+    tool,
+};
+use serde::Deserialize;
+use serde_json::{json, Value};
+use std::collections::HashMap;
+
+/// ${tool.description}
+#[derive(Debug, Deserialize)]
+pub struct ${toPascalCase(tool.name)}Input {
+${structFields || "    // No parameters"}
+}
+
+pub fn ${tool.name}_tool() -> Tool {
+    Tool {
+        name: "${tool.name}".to_string(),
+        description: Some("${tool.description}".to_string()),
+        input_schema: ToolInputSchema {
+            r#type: "object".to_string(),
+            properties: Some({
+                let mut props = HashMap::new();
+${tool.parameters.map(
+    (p) => `                props.insert(
+                    "${p.name}".to_string(),
+                    json!({
+                        "type": "${p.type}",
+                        "description": "${p.description}"
+                    }),
+                );`
+  ).join("\n")}
+                props
+            }),
+            required: Some(vec![${required}]),
+        },
+        handler: Box::new(|args| {
+            Box::pin(async move {
+                // TODO: Implement ${tool.name} logic
+                let input: ${toPascalCase(tool.name)}Input = serde_json::from_value(args.clone())?;
+
+                Ok(CallToolResult {
+                    content: vec![Content::Text {
+                        text: format!("${tool.name} called with: {:?}", args),
+                    }],
+                    is_error: None,
+                })
+            })
+        }),
+    }
+}
+`;
+}
+function mapTypeToGo(type) {
+  switch (type) {
+    case "number":
+      return "float64";
+    case "boolean":
+      return "bool";
+    case "array":
+      return "[]interface{}";
+    case "object":
+      return "map[string]interface{}";
+    default:
+      return "string";
+  }
+}
+function mapTypeToRust(type) {
+  switch (type) {
+    case "number":
+      return "f64";
+    case "boolean":
+      return "bool";
+    case "array":
+      return "Vec<Value>";
+    case "object":
+      return "HashMap<String, Value>";
+    default:
+      return "String";
+  }
+}
 
 export {
   projectNameRegex,

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   addToolCommand,
   createCommand,
   initCommand
-} from "./chunk-QRUHMGU5.js";
+} from "./chunk-K3TOM22I.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -11,13 +11,13 @@ import chalk from "chalk";
 var program = new Command();
 var logo = `
   ${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
-  ${chalk.cyan("\u2551")}   ${chalk.bold.white("mcp-new")}                            ${chalk.cyan("\u2551")}
+  ${chalk.cyan("\u2551")}   ${chalk.bold.white("mcp-generator")}                      ${chalk.cyan("\u2551")}
   ${chalk.cyan("\u2551")}   ${chalk.gray("Generate MCP servers in seconds")}    ${chalk.cyan("\u2551")}
   ${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
 `;
-program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("0.1.0").addHelpText("beforeAll", logo);
-program.argument("[project-name]", "Name of the project to create").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("--skip-install", "Skip dependency installation").option("--from-openapi <path>", "Generate from OpenAPI/Swagger specification").option("--from-prompt", "Generate tools using AI from text description").option("-y, --yes", "Skip prompts and use defaults").action(createCommand);
-program.command("init").description("Initialize MCP server in the current directory").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("--skip-install", "Skip dependency installation").option("-f, --force", "Initialize even if directory contains files").action(initCommand);
+program.name("mcp-generator").description("CLI tool for generating MCP (Model Context Protocol) servers").version("0.1.0").addHelpText("beforeAll", logo);
+program.argument("[project-name]", "Name of the project to create").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("--skip-install", "Skip dependency installation").option("--from-openapi <path>", "Generate from OpenAPI/Swagger specification").option("--from-prompt", "Generate tools using AI from text description").option("-y, --yes", "Skip prompts and use defaults").action(createCommand);
+program.command("init").description("Initialize MCP server in the current directory").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("-g, --go", "Use Go template").option("-r, --rust", "Use Rust template").option("--skip-install", "Skip dependency installation").option("-f, --force", "Initialize even if directory contains files").action(initCommand);
 program.command("add-tool").description("Add a new tool to an existing MCP server").option("-n, --name <name>", "Tool name (snake_case)").action(addToolCommand);
 program.parse();
 if (process.argv.length === 2) {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-declare const LanguageSchema: z.ZodEnum<["typescript", "python"]>;
+declare const LanguageSchema: z.ZodEnum<["typescript", "python", "go", "rust"]>;
 type Language = z.infer<typeof LanguageSchema>;
 declare const TransportSchema: z.ZodEnum<["stdio", "sse"]>;
 type Transport = z.infer<typeof TransportSchema>;
@@ -80,7 +80,7 @@ type ResourceConfig = z.infer<typeof ResourceConfigSchema>;
 declare const ProjectConfigSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodDefault<z.ZodString>;
-    language: z.ZodEnum<["typescript", "python"]>;
+    language: z.ZodEnum<["typescript", "python", "go", "rust"]>;
     transport: z.ZodEnum<["stdio", "sse"]>;
     tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
@@ -142,7 +142,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     description: string;
-    language: "typescript" | "python";
+    language: "typescript" | "python" | "go" | "rust";
     transport: "stdio" | "sse";
     tools: {
         name: string;
@@ -165,7 +165,7 @@ declare const ProjectConfigSchema: z.ZodObject<{
     initGit: boolean;
 }, {
     name: string;
-    language: "typescript" | "python";
+    language: "typescript" | "python" | "go" | "rust";
     transport: "stdio" | "sse";
     description?: string | undefined;
     tools?: {
@@ -197,6 +197,8 @@ interface GeneratorContext {
 interface CLIOptions {
     typescript?: boolean;
     python?: boolean;
+    go?: boolean;
+    rust?: boolean;
     skipInstall?: boolean;
     fromOpenapi?: string;
     fromPrompt?: boolean;
@@ -354,6 +356,8 @@ declare abstract class BaseGenerator {
     protected installDependencies(): Promise<void>;
     private installNodeDependencies;
     private installPythonDependencies;
+    private installGoDependencies;
+    private installRustDependencies;
     private checkCommand;
     protected initializeGit(): Promise<void>;
     protected checkOutputDir(): Promise<boolean>;
@@ -493,16 +497,18 @@ interface WizardOptions {
     defaultName?: string;
     skipDescription?: boolean;
     skipAdvanced?: boolean;
-    presetLanguage?: 'typescript' | 'python';
+    presetLanguage?: Language;
 }
 declare function runWizard(options?: WizardOptions): Promise<ProjectConfig>;
-declare function runQuickWizard(defaultName?: string, presetLanguage?: 'typescript' | 'python'): Promise<ProjectConfig>;
+declare function runQuickWizard(defaultName?: string, presetLanguage?: Language): Promise<ProjectConfig>;
 
 declare function createCommand(projectName: string | undefined, options: CLIOptions): Promise<void>;
 
 interface InitOptions {
     typescript?: boolean;
     python?: boolean;
+    go?: boolean;
+    rust?: boolean;
     skipInstall?: boolean;
     force?: boolean;
 }

package/dist/index.js

@@ -55,11 +55,11 @@ import {
   walkDir,
   withSpinner,
   writeFile
-} from "./chunk-QRUHMGU5.js";
+} from "./chunk-K3TOM22I.js";
 
 // src/types/config.ts
 import { z } from "zod";
-var LanguageSchema = z.enum(["typescript", "python"]);
+var LanguageSchema = z.enum(["typescript", "python", "go", "rust"]);
 var TransportSchema = z.enum(["stdio", "sse"]);
 var ToolParameterSchema = z.object({
   name: z.string(),

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "mcp-new",
-    "version": "0.1.0",
+    "version": "1.1.0",
     "description": "CLI generator for MCP servers. Like create-react-app, but for MCP.",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "bin": {
-        "mcp-new": "./bin/mcp-new.js"
+        "mcp-generator": "./bin/mcp-generator.js"
     },
     "files": [
         "dist",

package/templates/go/.env.example

@@ -0,0 +1,5 @@
+# Environment variables for the MCP server
+# Copy this file to .env and fill in the values
+
+# Add your environment variables here
+# API_KEY=your_api_key

package/templates/go/.gitignore.ejs

@@ -0,0 +1,30 @@
+# Binaries
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+<%= name %>
+
+# Test binary
+*.test
+
+# Output of the go coverage tool
+*.out
+
+# Dependency directories
+vendor/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+.env
+.env.local
+
+# Build
+/bin/
+/dist/

package/templates/go/README.md.ejs

@@ -0,0 +1,88 @@
+# <%= name %>
+
+<%= description || 'MCP Server generated by mcp-generator' %>
+
+## Overview
+
+This is an MCP (Model Context Protocol) server built with Go using the [mcp-go](https://github.com/mark3labs/mcp-go) SDK.
+
+## Prerequisites
+
+- Go 1.21 or higher
+- Git
+
+## Installation
+
+```bash
+# Install dependencies
+go mod download
+
+# Build the server
+go build -o <%= name %> ./cmd/server
+```
+
+## Running the Server
+
+<% if (transport === 'stdio') { %>
+### STDIO Transport
+
+```bash
+./<%= name %>
+```
+
+The server communicates via standard input/output.
+<% } else { %>
+### SSE Transport
+
+```bash
+./<%= name %>
+```
+
+The server will start an HTTP server with SSE endpoint.
+<% } %>
+
+## Available Tools
+
+<% if (includeExampleTool) { %>
+- **example_tool**: An example tool that echoes the input
+<% } %>
+<% tools.forEach(function(tool) { %>
+- **<%= tool.name %>**: <%= tool.description %>
+<% }); %>
+
+## Development
+
+```bash
+# Run in development mode
+go run ./cmd/server
+
+# Run tests
+go test ./...
+
+# Build for production
+go build -ldflags="-s -w" -o <%= name %> ./cmd/server
+```
+
+## Testing with MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector ./<%= name %>
+```
+
+## Project Structure
+
+```
+.
+├── cmd/
+│   └── server/
+│       └── main.go      # Server entry point
+├── internal/
+│   └── tools/           # Tool implementations
+├── go.mod
+├── go.sum
+└── README.md
+```
+
+## License
+
+MIT

package/templates/go/cmd/server/main.go.ejs

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+func main() {
+	// Create MCP server
+	s := server.NewMCPServer(
+		"<%= name %>",
+		"1.0.0",
+		server.WithToolCapabilities(true),
+	)
+
+<% if (includeExampleTool) { %>
+	// Register example tool
+	exampleTool := mcp.NewTool("example_tool",
+		mcp.WithDescription("An example tool that echoes the input"),
+		mcp.WithString("query",
+			mcp.Required(),
+			mcp.Description("The query to echo"),
+		),
+	)
+
+	s.AddTool(exampleTool, exampleToolHandler)
+<% } %>
+
+<% tools.forEach(function(tool) { %>
+	// Register <%= tool.name %> tool
+	<%= tool.name %>Tool := mcp.NewTool("<%= tool.name %>",
+		mcp.WithDescription("<%= tool.description %>"),
+<% tool.parameters.forEach(function(param, index) { %>
+<% if (param.type === 'string') { %>
+		mcp.WithString("<%= param.name %>",
+<% } else if (param.type === 'number') { %>
+		mcp.WithNumber("<%= param.name %>",
+<% } else if (param.type === 'boolean') { %>
+		mcp.WithBoolean("<%= param.name %>",
+<% } else { %>
+		mcp.WithString("<%= param.name %>",
+<% } %>
+<% if (param.required) { %>
+			mcp.Required(),
+<% } %>
+			mcp.Description("<%= param.description %>"),
+		),
+<% }); %>
+	)
+
+	s.AddTool(<%= tool.name %>Tool, <%= tool.name %>Handler)
+<% }); %>
+
+<% if (transport === 'stdio') { %>
+	// Start STDIO server
+	if err := server.ServeStdio(s); err != nil {
+		fmt.Fprintf(os.Stderr, "Server error: %v\n", err)
+		os.Exit(1)
+	}
+<% } else { %>
+	// Start SSE server
+	if err := server.ServeSSE(s, ":8080", "/messages"); err != nil {
+		fmt.Fprintf(os.Stderr, "Server error: %v\n", err)
+		os.Exit(1)
+	}
+<% } %>
+}
+
+<% if (includeExampleTool) { %>
+func exampleToolHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	query, ok := request.Params.Arguments["query"].(string)
+	if !ok {
+		return mcp.NewToolResultError("query parameter is required"), nil
+	}
+
+	return mcp.NewToolResultText(fmt.Sprintf("Echo: %s", query)), nil
+}
+<% } %>
+
+<% tools.forEach(function(tool) { %>
+func <%= tool.name %>Handler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// TODO: Implement <%= tool.name %> logic
+<% tool.parameters.forEach(function(param) { %>
+<% if (param.type === 'string') { %>
+	<%= param.name %>, _ := request.Params.Arguments["<%= param.name %>"].(string)
+<% } else if (param.type === 'number') { %>
+	<%= param.name %>, _ := request.Params.Arguments["<%= param.name %>"].(float64)
+<% } else if (param.type === 'boolean') { %>
+	<%= param.name %>, _ := request.Params.Arguments["<%= param.name %>"].(bool)
+<% } else { %>
+	<%= param.name %> := request.Params.Arguments["<%= param.name %>"]
+<% } %>
+<% }); %>
+
+	return mcp.NewToolResultText(fmt.Sprintf("<%= tool.name %> called with: %v", request.Params.Arguments)), nil
+}
+<% }); %>

package/templates/go/go.mod.ejs

@@ -0,0 +1,7 @@
+module <%= name %>
+
+go 1.21
+
+require (
+	github.com/mark3labs/mcp-go v0.6.0
+)

package/templates/go/internal/tools/example.go.ejs

@@ -0,0 +1,40 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/mark3labs/mcp-go/mcp"
+)
+
+// ExampleInput represents the input for the example tool
+type ExampleInput struct {
+	Query string `json:"query"`
+}
+
+// ExampleOutput represents the output of the example tool
+type ExampleOutput struct {
+	Result string `json:"result"`
+}
+
+// ExampleTool creates the example tool definition
+func ExampleTool() mcp.Tool {
+	return mcp.NewTool("example_tool",
+		mcp.WithDescription("An example tool that echoes the input"),
+		mcp.WithString("query",
+			mcp.Required(),
+			mcp.Description("The query to echo"),
+		),
+	)
+}
+
+// ExampleHandler handles the example tool execution
+func ExampleHandler(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	query, ok := request.Params.Arguments["query"].(string)
+	if !ok {
+		return mcp.NewToolResultError("query parameter is required"), nil
+	}
+
+	result := fmt.Sprintf("Echo: %s", query)
+	return mcp.NewToolResultText(result), nil
+}

package/templates/rust/.env.example

@@ -0,0 +1,8 @@
+# Environment variables for the MCP server
+# Copy this file to .env and fill in the values
+
+# Logging level
+RUST_LOG=info
+
+# Add your environment variables here
+# API_KEY=your_api_key

package/templates/rust/.gitignore.ejs

@@ -0,0 +1,19 @@
+# Generated by Cargo
+/target/
+
+# Cargo.lock for binaries
+Cargo.lock
+
+# Environment
+.env
+.env.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

package/templates/rust/Cargo.toml.ejs

@@ -0,0 +1,18 @@
+[package]
+name = "<%= name %>"
+version = "0.1.0"
+edition = "2021"
+description = "<%= description || 'MCP Server generated by mcp-generator' %>"
+
+[dependencies]
+rmcp = { version = "0.1", features = ["server"<% if (transport === 'stdio') { %>, "transport-io"<% } else { %>, "transport-sse-server"<% } %>] }
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+anyhow = "1"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+[[bin]]
+name = "<%= name %>"
+path = "src/main.rs"

package/templates/rust/README.md.ejs

@@ -0,0 +1,92 @@
+# <%= name %>
+
+<%= description || 'MCP Server generated by mcp-generator' %>
+
+## Overview
+
+This is an MCP (Model Context Protocol) server built with Rust using the [rmcp](https://github.com/anthropics/rmcp) SDK.
+
+## Prerequisites
+
+- Rust 1.70 or higher
+- Cargo
+
+## Installation
+
+```bash
+# Build the project
+cargo build --release
+```
+
+## Running the Server
+
+<% if (transport === 'stdio') { %>
+### STDIO Transport
+
+```bash
+cargo run --release
+# or
+./target/release/<%= name %>
+```
+
+The server communicates via standard input/output.
+<% } else { %>
+### SSE Transport
+
+```bash
+cargo run --release
+# or
+./target/release/<%= name %>
+```
+
+The server will start an HTTP server with SSE endpoint on port 8080.
+<% } %>
+
+## Available Tools
+
+<% if (includeExampleTool) { %>
+- **example_tool**: An example tool that echoes the input
+<% } %>
+<% tools.forEach(function(tool) { %>
+- **<%= tool.name %>**: <%= tool.description %>
+<% }); %>
+
+## Development
+
+```bash
+# Run in development mode
+cargo run
+
+# Run tests
+cargo test
+
+# Check for issues
+cargo clippy
+
+# Format code
+cargo fmt
+
+# Build release
+cargo build --release
+```
+
+## Testing with MCP Inspector
+
+```bash
+npx @modelcontextprotocol/inspector ./target/release/<%= name %>
+```
+
+## Project Structure
+
+```
+.
+├── src/
+│   ├── main.rs          # Server entry point
+│   └── tools.rs         # Tool implementations
+├── Cargo.toml
+└── README.md
+```
+
+## License
+
+MIT

package/templates/rust/src/main.rs.ejs

@@ -0,0 +1,46 @@
+use anyhow::Result;
+use rmcp::{
+    model::{CallToolResult, Content, Tool, ToolInputSchema},
+    server::Server,
+    tool,
+};
+use serde_json::{json, Value};
+use std::collections::HashMap;
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+mod tools;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize logging
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::EnvFilter::new(
+            std::env::var("RUST_LOG").unwrap_or_else(|_| "info".into()),
+        ))
+        .with(tracing_subscriber::fmt::layer().with_writer(std::io::stderr))
+        .init();
+
+    tracing::info!("Starting <%= name %> MCP server");
+
+    // Create server
+    let server = Server::builder()
+        .name("<%= name %>")
+        .version("1.0.0")
+<% if (includeExampleTool) { %>
+        .tool(tools::example_tool())
+<% } %>
+<% tools.forEach(function(tool) { %>
+        .tool(tools::<%= tool.name %>_tool())
+<% }); %>
+        .build();
+
+<% if (transport === 'stdio') { %>
+    // Run with STDIO transport
+    server.run_stdio().await?;
+<% } else { %>
+    // Run with SSE transport
+    server.run_sse("0.0.0.0:8080", "/messages").await?;
+<% } %>
+
+    Ok(())
+}

package/templates/rust/src/tools.rs.ejs

@@ -0,0 +1,105 @@
+use rmcp::{
+    model::{CallToolResult, Content, Tool, ToolInputSchema},
+    tool,
+};
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use std::collections::HashMap;
+
+<% if (includeExampleTool) { %>
+/// Example tool that echoes the input
+#[derive(Debug, Deserialize)]
+pub struct ExampleToolInput {
+    pub query: String,
+}
+
+pub fn example_tool() -> Tool {
+    Tool {
+        name: "example_tool".to_string(),
+        description: Some("An example tool that echoes the input".to_string()),
+        input_schema: ToolInputSchema {
+            r#type: "object".to_string(),
+            properties: Some({
+                let mut props = HashMap::new();
+                props.insert(
+                    "query".to_string(),
+                    json!({
+                        "type": "string",
+                        "description": "The query to echo"
+                    }),
+                );
+                props
+            }),
+            required: Some(vec!["query".to_string()]),
+        },
+        handler: Box::new(|args| {
+            Box::pin(async move {
+                let input: ExampleToolInput = serde_json::from_value(args)?;
+                Ok(CallToolResult {
+                    content: vec![Content::Text {
+                        text: format!("Echo: {}", input.query),
+                    }],
+                    is_error: None,
+                })
+            })
+        }),
+    }
+}
+<% } %>
+
+<% tools.forEach(function(tool) { %>
+/// <%= tool.description %>
+#[derive(Debug, Deserialize)]
+pub struct <%= tool.name.charAt(0).toUpperCase() + tool.name.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase()) %>Input {
+<% tool.parameters.forEach(function(param) { %>
+<% if (param.type === 'number') { %>
+    pub <%= param.name %>: f64,
+<% } else if (param.type === 'boolean') { %>
+    pub <%= param.name %>: bool,
+<% } else if (param.type === 'array') { %>
+    pub <%= param.name %>: Vec<Value>,
+<% } else if (param.type === 'object') { %>
+    pub <%= param.name %>: HashMap<String, Value>,
+<% } else { %>
+    pub <%= param.name %>: String,
+<% } %>
+<% }); %>
+}
+
+pub fn <%= tool.name %>_tool() -> Tool {
+    Tool {
+        name: "<%= tool.name %>".to_string(),
+        description: Some("<%= tool.description %>".to_string()),
+        input_schema: ToolInputSchema {
+            r#type: "object".to_string(),
+            properties: Some({
+                let mut props = HashMap::new();
+<% tool.parameters.forEach(function(param) { %>
+                props.insert(
+                    "<%= param.name %>".to_string(),
+                    json!({
+                        "type": "<%= param.type %>",
+                        "description": "<%= param.description %>"
+                    }),
+                );
+<% }); %>
+                props
+            }),
+            required: Some(vec![<%= tool.parameters.filter(p => p.required).map(p => '"' + p.name + '".to_string()').join(', ') %>]),
+        },
+        handler: Box::new(|args| {
+            Box::pin(async move {
+                // TODO: Implement <%= tool.name %> logic
+                let input: <%= tool.name.charAt(0).toUpperCase() + tool.name.slice(1).replace(/_([a-z])/g, (_, c) => c.toUpperCase()) %>Input = serde_json::from_value(args.clone())?;
+
+                Ok(CallToolResult {
+                    content: vec![Content::Text {
+                        text: format!("<%= tool.name %> called with: {:?}", args),
+                    }],
+                    is_error: None,
+                })
+            })
+        }),
+    }
+}
+<% }); %>