mcp-new 0.1.0 → 1.2.0

package/dist/{chunk-QRUHMGU5.js → chunk-BHGUGEHE.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"
     }
@@ -312,6 +314,381 @@ async function promptMultipleResources() {
   return resources;
 }
 
+// src/prompts/generation-method.ts
+import inquirer6 from "inquirer";
+async function promptGenerationMethod() {
+  const { method } = await inquirer6.prompt([
+    {
+      type: "list",
+      name: "method",
+      message: "How would you like to create your MCP server?",
+      choices: [
+        {
+          name: "From scratch (wizard)",
+          value: "wizard"
+        },
+        {
+          name: "From a preset template",
+          value: "preset"
+        },
+        {
+          name: "From OpenAPI/Swagger specification",
+          value: "openapi"
+        },
+        {
+          name: "Using AI (describe your API)",
+          value: "prompt"
+        }
+      ],
+      default: "wizard"
+    }
+  ]);
+  return method;
+}
+
+// src/prompts/preset.ts
+import inquirer7 from "inquirer";
+
+// src/presets/database.ts
+var DATABASE_PRESET = {
+  id: "database",
+  name: "Database CRUD",
+  description: "Tools for database operations: query, insert, update, delete",
+  tools: [
+    {
+      name: "query",
+      description: "Execute a SQL query on the database",
+      parameters: [
+        {
+          name: "sql",
+          type: "string",
+          description: "SQL query to execute",
+          required: true
+        },
+        {
+          name: "params",
+          type: "array",
+          description: "Query parameters for prepared statements",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "insert",
+      description: "Insert a new record into a table",
+      parameters: [
+        {
+          name: "table",
+          type: "string",
+          description: "Table name",
+          required: true
+        },
+        {
+          name: "data",
+          type: "object",
+          description: "Record data as key-value pairs",
+          required: true
+        }
+      ]
+    },
+    {
+      name: "update",
+      description: "Update records in a table",
+      parameters: [
+        {
+          name: "table",
+          type: "string",
+          description: "Table name",
+          required: true
+        },
+        {
+          name: "data",
+          type: "object",
+          description: "Fields to update as key-value pairs",
+          required: true
+        },
+        {
+          name: "where",
+          type: "object",
+          description: "WHERE conditions as key-value pairs",
+          required: true
+        }
+      ]
+    },
+    {
+      name: "delete",
+      description: "Delete records from a table",
+      parameters: [
+        {
+          name: "table",
+          type: "string",
+          description: "Table name",
+          required: true
+        },
+        {
+          name: "where",
+          type: "object",
+          description: "WHERE conditions as key-value pairs",
+          required: true
+        }
+      ]
+    },
+    {
+      name: "list_tables",
+      description: "List all tables in the database",
+      parameters: []
+    }
+  ]
+};
+
+// src/presets/rest-api.ts
+var REST_API_PRESET = {
+  id: "rest-api",
+  name: "REST API Wrapper",
+  description: "Tools for making HTTP requests: GET, POST, PUT, DELETE",
+  tools: [
+    {
+      name: "http_get",
+      description: "Make an HTTP GET request",
+      parameters: [
+        {
+          name: "url",
+          type: "string",
+          description: "URL to request (can be relative if base_url is set)",
+          required: true
+        },
+        {
+          name: "headers",
+          type: "object",
+          description: "Request headers as key-value pairs",
+          required: false
+        },
+        {
+          name: "query",
+          type: "object",
+          description: "Query parameters as key-value pairs",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "http_post",
+      description: "Make an HTTP POST request",
+      parameters: [
+        {
+          name: "url",
+          type: "string",
+          description: "URL to request",
+          required: true
+        },
+        {
+          name: "body",
+          type: "object",
+          description: "Request body (will be JSON encoded)",
+          required: false
+        },
+        {
+          name: "headers",
+          type: "object",
+          description: "Request headers as key-value pairs",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "http_put",
+      description: "Make an HTTP PUT request",
+      parameters: [
+        {
+          name: "url",
+          type: "string",
+          description: "URL to request",
+          required: true
+        },
+        {
+          name: "body",
+          type: "object",
+          description: "Request body (will be JSON encoded)",
+          required: false
+        },
+        {
+          name: "headers",
+          type: "object",
+          description: "Request headers as key-value pairs",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "http_delete",
+      description: "Make an HTTP DELETE request",
+      parameters: [
+        {
+          name: "url",
+          type: "string",
+          description: "URL to request",
+          required: true
+        },
+        {
+          name: "headers",
+          type: "object",
+          description: "Request headers as key-value pairs",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "set_base_url",
+      description: "Set the base URL for all subsequent requests",
+      parameters: [
+        {
+          name: "base_url",
+          type: "string",
+          description: "Base URL (e.g., https://api.example.com)",
+          required: true
+        }
+      ]
+    }
+  ]
+};
+
+// src/presets/filesystem.ts
+var FILESYSTEM_PRESET = {
+  id: "filesystem",
+  name: "File System Tools",
+  description: "Tools for file operations: read, write, list, search",
+  tools: [
+    {
+      name: "read_file",
+      description: "Read the contents of a file",
+      parameters: [
+        {
+          name: "path",
+          type: "string",
+          description: "Path to the file to read",
+          required: true
+        },
+        {
+          name: "encoding",
+          type: "string",
+          description: "File encoding (default: utf-8)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "write_file",
+      description: "Write content to a file",
+      parameters: [
+        {
+          name: "path",
+          type: "string",
+          description: "Path to the file to write",
+          required: true
+        },
+        {
+          name: "content",
+          type: "string",
+          description: "Content to write to the file",
+          required: true
+        },
+        {
+          name: "append",
+          type: "boolean",
+          description: "Append to file instead of overwriting (default: false)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "list_directory",
+      description: "List files and directories in a path",
+      parameters: [
+        {
+          name: "path",
+          type: "string",
+          description: "Directory path to list",
+          required: true
+        },
+        {
+          name: "recursive",
+          type: "boolean",
+          description: "List recursively (default: false)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "search_files",
+      description: "Search for files matching a pattern",
+      parameters: [
+        {
+          name: "path",
+          type: "string",
+          description: "Directory to search in",
+          required: true
+        },
+        {
+          name: "pattern",
+          type: "string",
+          description: "Glob pattern to match (e.g., *.txt)",
+          required: true
+        },
+        {
+          name: "recursive",
+          type: "boolean",
+          description: "Search recursively (default: true)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "file_info",
+      description: "Get information about a file or directory",
+      parameters: [
+        {
+          name: "path",
+          type: "string",
+          description: "Path to the file or directory",
+          required: true
+        }
+      ]
+    }
+  ]
+};
+
+// src/presets/index.ts
+var PRESETS = {
+  database: DATABASE_PRESET,
+  "rest-api": REST_API_PRESET,
+  filesystem: FILESYSTEM_PRESET
+};
+var PRESET_IDS = Object.keys(PRESETS);
+function getPreset(id) {
+  return PRESETS[id];
+}
+function isValidPresetId(id) {
+  return id in PRESETS;
+}
+
+// src/prompts/preset.ts
+async function promptPreset() {
+  const choices = Object.values(PRESETS).map((preset2) => ({
+    name: `${preset2.name} - ${preset2.description}`,
+    value: preset2.id
+  }));
+  const { preset } = await inquirer7.prompt([
+    {
+      type: "list",
+      name: "preset",
+      message: "Select a preset template:",
+      choices,
+      default: "database"
+    }
+  ]);
+  return preset;
+}
+
 // src/prompts/index.ts
 async function runWizard(options = {}) {
   const name = await promptProjectName(options.defaultName);
@@ -528,11 +905,34 @@ var logger = {
   },
   nextSteps: (projectName, language) => {
     logger.blank();
+    let installCmd;
+    let runCmd;
+    switch (language) {
+      case "typescript":
+        installCmd = "npm install";
+        runCmd = "npm run dev";
+        break;
+      case "python":
+        installCmd = "pip install -e .";
+        runCmd = "python -m src.server";
+        break;
+      case "go":
+        installCmd = "go mod download";
+        runCmd = "go run ./cmd/server";
+        break;
+      case "rust":
+        installCmd = "cargo build";
+        runCmd = "cargo run";
+        break;
+      default:
+        installCmd = "npm install";
+        runCmd = "npm run dev";
+    }
     logger.box("Next steps:", [
       "",
       `  ${chalk.cyan("cd")} ${projectName}`,
-      language === "typescript" ? `  ${chalk.cyan("npm install")}` : `  ${chalk.cyan("pip install -e .")}`,
-      language === "typescript" ? `  ${chalk.cyan("npm run dev")}` : `  ${chalk.cyan("python -m src.server")}`,
+      `  ${chalk.cyan(installCmd)}`,
+      `  ${chalk.cyan(runCmd)}`,
       ""
     ]);
   }
@@ -639,11 +1039,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 +1084,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;
@@ -764,7 +1212,7 @@ async function generateFromWizard(config, outputPath) {
 
 // src/parsers/openapi.ts
 import YAML from "yaml";
-import inquirer6 from "inquirer";
+import inquirer8 from "inquirer";
 async function parseOpenAPISpec(content) {
   let spec;
   try {
@@ -864,7 +1312,7 @@ async function selectEndpoints(endpoints) {
     value: ep,
     checked: true
   }));
-  const { selected } = await inquirer6.prompt([
+  const { selected } = await inquirer8.prompt([
     {
       type: "checkbox",
       name: "selected",
@@ -1000,7 +1448,7 @@ function mapOpenAPIType(type) {
 
 // src/generators/from-prompt.ts
 import Anthropic from "@anthropic-ai/sdk";
-import inquirer7 from "inquirer";
+import inquirer9 from "inquirer";
 var SYSTEM_PROMPT = `You are an expert at designing MCP (Model Context Protocol) servers.
 Given a description of an API or functionality, you generate a list of tools that would be useful for that API.
 
@@ -1058,7 +1506,7 @@ var PromptGenerator = class extends BaseGenerator {
   }
 };
 async function generateFromPrompt(baseConfig) {
-  const { description } = await inquirer7.prompt([
+  const { description } = await inquirer9.prompt([
     {
       type: "editor",
       name: "description",
@@ -1114,7 +1562,7 @@ async function generateFromPrompt(baseConfig) {
     logger.list([`${index + 1}. ${tool.name} - ${tool.description}`]);
   });
   logger.blank();
-  const { confirm } = await inquirer7.prompt([
+  const { confirm } = await inquirer9.prompt([
     {
       type: "confirm",
       name: "confirm",
@@ -1141,10 +1589,85 @@ async function generateFromPrompt(baseConfig) {
   await generator.generate();
 }
 
+// src/generators/from-preset.ts
+var PresetGenerator = class extends BaseGenerator {
+  presetName;
+  constructor(context, presetName) {
+    super(context);
+    this.presetName = presetName;
+  }
+  async generate() {
+    logger.title(`Creating ${this.config.name} from "${this.presetName}" preset`);
+    const isSafe = await this.checkOutputDir();
+    if (!isSafe) {
+      throw new Error(
+        `Directory ${this.outputDir} already exists and is not empty. Please choose a different name or delete the existing directory.`
+      );
+    }
+    await withSpinner(
+      "Creating project structure...",
+      async () => {
+        await this.createProjectStructure();
+      },
+      "Project structure created"
+    );
+    await withSpinner(
+      "Generating files from templates...",
+      async () => {
+        await this.renderTemplates();
+      },
+      "Files generated"
+    );
+    await this.installDependencies();
+    await this.initializeGit();
+    logger.success(`Project ${this.config.name} created successfully!`);
+    logger.info(`Preset: ${this.presetName}`);
+    logger.info(`Tools included: ${this.config.tools.map((t) => t.name).join(", ")}`);
+    logger.nextSteps(this.config.name, this.config.language);
+  }
+};
+async function generateFromPreset(options) {
+  const preset = getPreset(options.presetId);
+  if (!preset) {
+    throw new Error(`Invalid preset: ${options.presetId}`);
+  }
+  const name = options.projectName || await promptProjectName();
+  const description = options.useDefaults ? "" : await promptProjectDescription();
+  const language = options.language || (options.useDefaults ? "typescript" : await promptLanguage());
+  const transport = options.useDefaults ? "stdio" : await promptTransport();
+  const config = {
+    name,
+    description,
+    language,
+    transport,
+    tools: preset.tools,
+    resources: [],
+    includeExampleTool: false,
+    skipInstall: options.skipInstall || false,
+    initGit: true
+  };
+  const context = createGeneratorContext(config);
+  const generator = new PresetGenerator(context, preset.name);
+  await generator.generate();
+}
+function validatePresetId(presetId) {
+  if (!isValidPresetId(presetId)) {
+    const validPresets = ["database", "rest-api", "filesystem"];
+    throw new Error(
+      `Invalid preset "${presetId}". Valid presets are: ${validPresets.join(", ")}`
+    );
+  }
+  return true;
+}
+
 // src/commands/create.ts
 import path4 from "path";
 async function createCommand(projectName, options) {
   try {
+    if (options.preset) {
+      await handlePresetGeneration(projectName, options);
+      return;
+    }
     if (options.fromOpenapi) {
       await handleOpenAPIGeneration(projectName, options);
       return;
@@ -1165,7 +1688,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,29 +1716,42 @@ 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
   });
 }
+async function handlePresetGeneration(projectName, options) {
+  const presetId = options.preset;
+  validatePresetId(presetId);
+  await generateFromPreset({
+    projectName,
+    presetId,
+    language: options.typescript ? "typescript" : options.python ? "python" : options.go ? "go" : options.rust ? "rust" : void 0,
+    skipInstall: options.skipInstall,
+    useDefaults: options.yes
+  });
+}
 
 // src/commands/init.ts
 import path5 from "path";
-import inquirer8 from "inquirer";
+import inquirer10 from "inquirer";
 async function initCommand(options) {
   try {
     const currentDir = process.cwd();
     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 { proceed } = await inquirer8.prompt([
+    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 inquirer10.prompt([
         {
           type: "confirm",
           name: "proceed",
@@ -1233,12 +1769,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 +1829,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 +1849,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 +2031,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,
@@ -1499,6 +2218,8 @@ export {
   promptAddResources,
   promptResourceConfig,
   promptMultipleResources,
+  promptGenerationMethod,
+  promptPreset,
   runWizard,
   runQuickWizard,
   ensureDir,
@@ -1534,6 +2255,9 @@ export {
   generateFromOpenAPI,
   PromptGenerator,
   generateFromPrompt,
+  PresetGenerator,
+  generateFromPreset,
+  validatePresetId,
   createCommand,
   initCommand,
   addToolCommand