mcp-new 1.2.1 → 1.2.2

package/README.md

@@ -124,6 +124,18 @@ mcp-new init
 
 # Add a new tool to existing project
 mcp-new add-tool
+
+# List all available presets
+mcp-new list-presets
+
+# Validate current MCP server project
+mcp-new validate
+
+# Upgrade MCP SDK to latest version
+mcp-new upgrade
+
+# Check for updates without installing
+mcp-new upgrade --check
 ```
 
 ---
@@ -151,6 +163,9 @@ Options:
 Commands:
   init                   Initialize in current directory
   add-tool               Add tool to existing project
+  list-presets           List all available preset templates
+  validate               Validate current MCP server project
+  upgrade                Upgrade MCP SDK to latest version
 ```
 
 ### Generated Project Structure

package/dist/{chunk-BHGUGEHE.js → chunk-3JG4FVS2.js}

@@ -2219,6 +2219,7 @@ export {
   promptResourceConfig,
   promptMultipleResources,
   promptGenerationMethod,
+  PRESETS,
   promptPreset,
   runWizard,
   runQuickWizard,

package/dist/cli.js

@@ -1,84 +1,531 @@
 #!/usr/bin/env node
 import {
+  PRESETS,
   addToolCommand,
   createCommand,
-  initCommand
-} from "./chunk-BHGUGEHE.js";
+  createSpinner,
+  initCommand,
+  logger
+} from "./chunk-3JG4FVS2.js";
 
 // src/cli.ts
 import { Command } from "commander";
+import chalk4 from "chalk";
+
+// src/commands/list-presets.ts
 import chalk from "chalk";
+async function listPresetsCommand() {
+  console.log();
+  console.log(chalk.bold.white("Available Presets"));
+  console.log(chalk.gray("\u2500".repeat(60)));
+  console.log();
+  for (const [id, preset] of Object.entries(PRESETS)) {
+    console.log(chalk.yellow.bold(`  ${id}`));
+    console.log(chalk.gray(`  ${preset.description}`));
+    console.log();
+    console.log(chalk.white("  Tools:"));
+    for (const tool of preset.tools) {
+      const paramCount = tool.parameters.length;
+      const paramText = paramCount === 0 ? chalk.gray("no params") : chalk.gray(`${paramCount} param${paramCount > 1 ? "s" : ""}`);
+      console.log(`    ${chalk.cyan("\u2022")} ${chalk.white(tool.name)} ${paramText}`);
+      console.log(`      ${chalk.gray(tool.description)}`);
+    }
+    console.log();
+    console.log(chalk.gray("  " + "\u2500".repeat(56)));
+    console.log();
+  }
+  console.log(chalk.bold.white("Usage:"));
+  console.log();
+  console.log(chalk.gray("  $"), chalk.cyan("mcp-new my-project --preset database"));
+  console.log(chalk.gray("  $"), chalk.cyan("mcp-new my-api --preset rest-api -t"));
+  console.log(chalk.gray("  $"), chalk.cyan("mcp-new my-fs --preset filesystem -p"));
+  console.log();
+}
+
+// src/commands/validate.ts
+import path from "path";
+import fs from "fs-extra";
+import chalk2 from "chalk";
+async function validateCommand() {
+  const currentDir = process.cwd();
+  logger.title("Validating MCP Server");
+  const result = await validateProject(currentDir);
+  console.log();
+  if (result.language) {
+    console.log(chalk2.blue("i"), `Detected language: ${chalk2.cyan(result.language)}`);
+  }
+  for (const info of result.info) {
+    console.log(chalk2.blue("i"), info);
+  }
+  for (const warning of result.warnings) {
+    console.log(chalk2.yellow("\u26A0"), warning);
+  }
+  for (const error of result.errors) {
+    console.log(chalk2.red("\u2717"), error);
+  }
+  console.log();
+  if (result.valid) {
+    logger.success("MCP server is valid!");
+  } else {
+    logger.error("Validation failed. Please fix the issues above.");
+    process.exit(1);
+  }
+}
+async function validateProject(projectDir) {
+  const result = {
+    valid: true,
+    language: null,
+    errors: [],
+    warnings: [],
+    info: []
+  };
+  const hasPackageJson = await fs.pathExists(path.join(projectDir, "package.json"));
+  const hasPyproject = await fs.pathExists(path.join(projectDir, "pyproject.toml"));
+  const hasGoMod = await fs.pathExists(path.join(projectDir, "go.mod"));
+  const hasCargoToml = await fs.pathExists(path.join(projectDir, "Cargo.toml"));
+  if (!hasPackageJson && !hasPyproject && !hasGoMod && !hasCargoToml) {
+    result.errors.push("No project configuration found (package.json, pyproject.toml, go.mod, or Cargo.toml)");
+    result.valid = false;
+    return result;
+  }
+  if (hasPackageJson) {
+    result.language = "typescript";
+    await validateTypeScriptProject(projectDir, result);
+  }
+  if (hasPyproject) {
+    result.language = "python";
+    await validatePythonProject(projectDir, result);
+  }
+  if (hasGoMod) {
+    result.language = "go";
+    await validateGoProject(projectDir, result);
+  }
+  if (hasCargoToml) {
+    result.language = "rust";
+    await validateRustProject(projectDir, result);
+  }
+  return result;
+}
+async function validateTypeScriptProject(projectDir, result) {
+  try {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    const packageJson = await fs.readJson(packageJsonPath);
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    if (deps["@modelcontextprotocol/sdk"]) {
+      result.info.push(`MCP SDK version: ${chalk2.green(deps["@modelcontextprotocol/sdk"])}`);
+    } else {
+      result.errors.push("Missing @modelcontextprotocol/sdk dependency");
+      result.valid = false;
+    }
+    const srcIndex = path.join(projectDir, "src", "index.ts");
+    const srcIndexJs = path.join(projectDir, "src", "index.js");
+    const distIndex = path.join(projectDir, "dist", "index.js");
+    if (await fs.pathExists(srcIndex)) {
+      result.info.push("Entry point: src/index.ts");
+      await validateTypeScriptEntryPoint(srcIndex, result);
+    } else if (await fs.pathExists(srcIndexJs)) {
+      result.info.push("Entry point: src/index.js");
+    } else if (await fs.pathExists(distIndex)) {
+      result.info.push("Entry point: dist/index.js (built)");
+    } else {
+      result.warnings.push("No entry point found (expected src/index.ts or src/index.js)");
+    }
+    if (await fs.pathExists(path.join(projectDir, "tsconfig.json"))) {
+      result.info.push("TypeScript config: tsconfig.json");
+    } else {
+      result.warnings.push("No tsconfig.json found");
+    }
+    if (packageJson.scripts?.build) {
+      result.info.push(`Build script: ${chalk2.gray(packageJson.scripts.build)}`);
+    } else {
+      result.warnings.push("No build script found in package.json");
+    }
+  } catch (error) {
+    result.errors.push("Failed to parse package.json");
+    result.valid = false;
+  }
+}
+async function validateTypeScriptEntryPoint(filePath, result) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    if (content.includes("@modelcontextprotocol/sdk")) {
+      result.info.push("MCP SDK import found");
+    } else {
+      result.warnings.push("No MCP SDK import found in entry point");
+    }
+    if (content.includes("McpServer") || content.includes("Server")) {
+      result.info.push("MCP Server class usage found");
+    } else {
+      result.warnings.push("No MCP Server class found");
+    }
+    const toolMatches = content.match(/\.tool\s*\(/g) || content.match(/setRequestHandler.*CallToolRequest/g);
+    if (toolMatches) {
+      result.info.push(`Tools defined: ${chalk2.green(toolMatches.length)}`);
+    }
+  } catch {
+    result.warnings.push("Could not analyze entry point file");
+  }
+}
+async function validatePythonProject(projectDir, result) {
+  try {
+    const pyprojectPath = path.join(projectDir, "pyproject.toml");
+    const content = await fs.readFile(pyprojectPath, "utf-8");
+    if (content.includes("mcp") || content.includes("modelcontextprotocol")) {
+      result.info.push("MCP dependency found in pyproject.toml");
+    } else {
+      const requirementsPath = path.join(projectDir, "requirements.txt");
+      if (await fs.pathExists(requirementsPath)) {
+        const requirements = await fs.readFile(requirementsPath, "utf-8");
+        if (requirements.includes("mcp")) {
+          result.info.push("MCP dependency found in requirements.txt");
+        } else {
+          result.errors.push("Missing MCP dependency");
+          result.valid = false;
+        }
+      } else {
+        result.warnings.push("No requirements.txt found");
+      }
+    }
+    const serverPath = path.join(projectDir, "src", "server.py");
+    if (await fs.pathExists(serverPath)) {
+      result.info.push("Server file: src/server.py");
+    } else {
+      result.warnings.push("No server.py found in src/");
+    }
+  } catch (error) {
+    result.errors.push("Failed to parse pyproject.toml");
+    result.valid = false;
+  }
+}
+async function validateGoProject(projectDir, result) {
+  try {
+    const goModPath = path.join(projectDir, "go.mod");
+    const content = await fs.readFile(goModPath, "utf-8");
+    if (content.includes("mcp-go") || content.includes("modelcontextprotocol")) {
+      result.info.push("MCP Go SDK found in go.mod");
+    } else {
+      result.errors.push("Missing MCP Go SDK dependency");
+      result.valid = false;
+    }
+    const mainPath = path.join(projectDir, "cmd", "server", "main.go");
+    const altMainPath = path.join(projectDir, "main.go");
+    if (await fs.pathExists(mainPath)) {
+      result.info.push("Entry point: cmd/server/main.go");
+    } else if (await fs.pathExists(altMainPath)) {
+      result.info.push("Entry point: main.go");
+    } else {
+      result.warnings.push("No main.go found");
+    }
+  } catch (error) {
+    result.errors.push("Failed to parse go.mod");
+    result.valid = false;
+  }
+}
+async function validateRustProject(projectDir, result) {
+  try {
+    const cargoPath = path.join(projectDir, "Cargo.toml");
+    const content = await fs.readFile(cargoPath, "utf-8");
+    if (content.includes("rmcp") || content.includes("mcp")) {
+      result.info.push("MCP Rust SDK found in Cargo.toml");
+    } else {
+      result.errors.push("Missing MCP Rust SDK dependency");
+      result.valid = false;
+    }
+    const mainPath = path.join(projectDir, "src", "main.rs");
+    if (await fs.pathExists(mainPath)) {
+      result.info.push("Entry point: src/main.rs");
+    } else {
+      result.warnings.push("No main.rs found");
+    }
+  } catch (error) {
+    result.errors.push("Failed to parse Cargo.toml");
+    result.valid = false;
+  }
+}
+
+// src/commands/upgrade.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+import chalk3 from "chalk";
+import { execa } from "execa";
+async function upgradeCommand(options) {
+  const currentDir = process.cwd();
+  logger.title("MCP SDK Upgrade");
+  const hasPackageJson = await fs2.pathExists(path2.join(currentDir, "package.json"));
+  const hasPyproject = await fs2.pathExists(path2.join(currentDir, "pyproject.toml"));
+  const hasGoMod = await fs2.pathExists(path2.join(currentDir, "go.mod"));
+  const hasCargoToml = await fs2.pathExists(path2.join(currentDir, "Cargo.toml"));
+  if (!hasPackageJson && !hasPyproject && !hasGoMod && !hasCargoToml) {
+    logger.error("No project configuration found.");
+    logger.info("Run this command from the root of your MCP server project.");
+    process.exit(1);
+  }
+  let info = null;
+  if (hasPackageJson) {
+    info = await checkNodePackage(currentDir);
+  } else if (hasPyproject) {
+    info = await checkPythonPackage(currentDir);
+  } else if (hasGoMod) {
+    info = await checkGoPackage(currentDir);
+  } else if (hasCargoToml) {
+    info = await checkRustPackage(currentDir);
+  }
+  if (!info) {
+    logger.error("Could not detect MCP SDK version.");
+    process.exit(1);
+  }
+  console.log();
+  console.log(chalk3.blue("i"), `Package: ${chalk3.cyan(info.packageName)}`);
+  console.log(chalk3.blue("i"), `Current version: ${info.current ? chalk3.yellow(info.current) : chalk3.gray("not installed")}`);
+  console.log(chalk3.blue("i"), `Latest version: ${info.latest ? chalk3.green(info.latest) : chalk3.gray("unknown")}`);
+  console.log();
+  if (options.check) {
+    if (info.current === info.latest) {
+      logger.success("Already up to date!");
+    } else if (info.latest) {
+      logger.info(`Update available: ${info.current} \u2192 ${info.latest}`);
+      logger.code(`mcp-new upgrade`);
+    }
+    return;
+  }
+  if (info.current === info.latest) {
+    logger.success("Already up to date!");
+    return;
+  }
+  if (!info.latest) {
+    logger.error("Could not fetch latest version.");
+    process.exit(1);
+  }
+  const spinner = createSpinner(`Upgrading ${info.packageName}...`);
+  spinner.start();
+  try {
+    if (hasPackageJson) {
+      await upgradeNodePackage(currentDir, info);
+    } else if (hasPyproject) {
+      await upgradePythonPackage(currentDir, info);
+    } else if (hasGoMod) {
+      await upgradeGoPackage(currentDir, info);
+    } else if (hasCargoToml) {
+      await upgradeRustPackage(currentDir, info);
+    }
+    spinner.succeed(`Upgraded to ${info.packageName}@${info.latest}`);
+    logger.blank();
+    logger.success("MCP SDK upgraded successfully!");
+  } catch (error) {
+    spinner.fail("Upgrade failed");
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+    process.exit(1);
+  }
+}
+async function checkNodePackage(projectDir) {
+  const packageName = "@modelcontextprotocol/sdk";
+  let current = null;
+  let latest = null;
+  try {
+    const packageJson = await fs2.readJson(path2.join(projectDir, "package.json"));
+    const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    current = deps[packageName]?.replace(/[\^~]/, "") || null;
+  } catch {
+  }
+  try {
+    const { stdout } = await execa("npm", ["view", packageName, "version"]);
+    latest = stdout.trim();
+  } catch {
+  }
+  return { current, latest, packageManager: "npm", packageName };
+}
+async function upgradeNodePackage(projectDir, info) {
+  const packageJsonPath = path2.join(projectDir, "package.json");
+  const packageJson = await fs2.readJson(packageJsonPath);
+  if (packageJson.dependencies?.[info.packageName]) {
+    packageJson.dependencies[info.packageName] = `^${info.latest}`;
+  } else if (packageJson.devDependencies?.[info.packageName]) {
+    packageJson.devDependencies[info.packageName] = `^${info.latest}`;
+  }
+  await fs2.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  await execa("npm", ["install"], { cwd: projectDir });
+}
+async function checkPythonPackage(projectDir) {
+  const packageName = "mcp";
+  let current = null;
+  let latest = null;
+  try {
+    const { stdout } = await execa("pip", ["show", packageName]);
+    const versionMatch = stdout.match(/Version:\s*(\S+)/);
+    current = versionMatch?.[1] || null;
+  } catch {
+  }
+  try {
+    const { stdout } = await execa("pip", ["index", "versions", packageName]);
+    const match = stdout.match(/Available versions:\s*([^\s,]+)/);
+    latest = match?.[1] || null;
+  } catch {
+    try {
+      const { stdout } = await execa("pip", ["install", `${packageName}==`, "--dry-run"], { reject: false });
+      const match = stdout.match(/from versions:\s*([^)]+)\)/);
+      if (match) {
+        const versions = match[1].split(",").map((v) => v.trim());
+        latest = versions[versions.length - 1] || null;
+      }
+    } catch {
+    }
+  }
+  return { current, latest, packageManager: "pip", packageName };
+}
+async function upgradePythonPackage(_projectDir, info) {
+  await execa("pip", ["install", "--upgrade", info.packageName]);
+}
+async function checkGoPackage(projectDir) {
+  const packageName = "github.com/mark3labs/mcp-go";
+  let current = null;
+  let latest = null;
+  try {
+    const goModContent = await fs2.readFile(path2.join(projectDir, "go.mod"), "utf-8");
+    const match = goModContent.match(new RegExp(`${packageName.replace(/\//g, "\\/")}\\s+v([\\d.]+)`));
+    current = match?.[1] || null;
+  } catch {
+  }
+  try {
+    const { stdout } = await execa("go", ["list", "-m", "-versions", packageName]);
+    const versions = stdout.split(" ").slice(1);
+    latest = versions[versions.length - 1]?.replace("v", "") || null;
+  } catch {
+  }
+  return { current, latest, packageManager: "go", packageName };
+}
+async function upgradeGoPackage(projectDir, info) {
+  await execa("go", ["get", "-u", `${info.packageName}@latest`], { cwd: projectDir });
+  await execa("go", ["mod", "tidy"], { cwd: projectDir });
+}
+async function checkRustPackage(projectDir) {
+  const packageName = "rmcp";
+  let current = null;
+  let latest = null;
+  try {
+    const cargoContent = await fs2.readFile(path2.join(projectDir, "Cargo.toml"), "utf-8");
+    const match = cargoContent.match(/rmcp\s*=\s*["']([^"']+)["']/);
+    current = match?.[1] || null;
+  } catch {
+  }
+  try {
+    const { stdout } = await execa("cargo", ["search", packageName, "--limit", "1"]);
+    const match = stdout.match(/rmcp\s*=\s*"([^"]+)"/);
+    latest = match?.[1] || null;
+  } catch {
+  }
+  return { current, latest, packageManager: "cargo", packageName };
+}
+async function upgradeRustPackage(projectDir, info) {
+  await execa("cargo", ["update", "-p", info.packageName], { cwd: projectDir });
+}
+
+// src/cli.ts
 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.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")}
+  ${chalk4.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")}
+  ${chalk4.cyan("\u2551")}   ${chalk4.bold.white("mcp-new")}                            ${chalk4.cyan("\u2551")}
+  ${chalk4.cyan("\u2551")}   ${chalk4.gray("Generate MCP servers in seconds")}    ${chalk4.cyan("\u2551")}
+  ${chalk4.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")}
 `;
 var examples = `
-${chalk.bold("Examples:")}
+${chalk4.bold("Examples:")}
 
-  ${chalk.gray("# Create a new MCP server with interactive wizard")}
-  ${chalk.cyan("$")} mcp-new my-server
+  ${chalk4.gray("# Create a new MCP server with interactive wizard")}
+  ${chalk4.cyan("$")} mcp-new my-server
 
-  ${chalk.gray("# Create TypeScript server with defaults")}
-  ${chalk.cyan("$")} mcp-new my-server -t -y
+  ${chalk4.gray("# Create TypeScript server with defaults")}
+  ${chalk4.cyan("$")} mcp-new my-server -t -y
 
-  ${chalk.gray("# Create Python server")}
-  ${chalk.cyan("$")} mcp-new my-server -p
+  ${chalk4.gray("# Create Python server")}
+  ${chalk4.cyan("$")} mcp-new my-server -p
 
-  ${chalk.gray("# Create from preset template")}
-  ${chalk.cyan("$")} mcp-new my-db --preset database
-  ${chalk.cyan("$")} mcp-new my-api --preset rest-api
-  ${chalk.cyan("$")} mcp-new my-fs --preset filesystem
+  ${chalk4.gray("# Create from preset template")}
+  ${chalk4.cyan("$")} mcp-new my-db --preset database
+  ${chalk4.cyan("$")} mcp-new my-api --preset rest-api
+  ${chalk4.cyan("$")} mcp-new my-fs --preset filesystem
 
-  ${chalk.gray("# Create from OpenAPI specification")}
-  ${chalk.cyan("$")} mcp-new my-api --from-openapi ./openapi.yaml
+  ${chalk4.gray("# Create from OpenAPI specification")}
+  ${chalk4.cyan("$")} mcp-new my-api --from-openapi ./openapi.yaml
 
-  ${chalk.gray("# Create using AI (requires ANTHROPIC_API_KEY)")}
-  ${chalk.cyan("$")} mcp-new my-server --from-prompt
+  ${chalk4.gray("# Create using AI (requires ANTHROPIC_API_KEY)")}
+  ${chalk4.cyan("$")} mcp-new my-server --from-prompt
 
-${chalk.bold("Available Presets:")}
+${chalk4.bold("Available Presets:")}
 
-  ${chalk.yellow("database")}     Database CRUD tools (query, insert, update, delete, list_tables)
-  ${chalk.yellow("rest-api")}     REST API tools (http_get, http_post, http_put, http_delete, set_base_url)
-  ${chalk.yellow("filesystem")}   File system tools (read_file, write_file, list_directory, search_files, file_info)
+  ${chalk4.yellow("database")}     Database CRUD tools (query, insert, update, delete, list_tables)
+  ${chalk4.yellow("rest-api")}     REST API tools (http_get, http_post, http_put, http_delete, set_base_url)
+  ${chalk4.yellow("filesystem")}   File system tools (read_file, write_file, list_directory, search_files, file_info)
 
-${chalk.bold("Supported Languages:")}
+${chalk4.bold("Supported Languages:")}
 
-  ${chalk.green("-t, --typescript")}   TypeScript with npm
-  ${chalk.green("-p, --python")}       Python with pip
-  ${chalk.green("-g, --go")}           Go with go modules
-  ${chalk.green("-r, --rust")}         Rust with cargo
+  ${chalk4.green("-t, --typescript")}   TypeScript with npm
+  ${chalk4.green("-p, --python")}       Python with pip
+  ${chalk4.green("-g, --go")}           Go with go modules
+  ${chalk4.green("-r, --rust")}         Rust with cargo
 
-${chalk.bold("Learn More:")}
+${chalk4.bold("Learn More:")}
 
-  Documentation:  ${chalk.underline("https://github.com/d1maash/mcp-new")}
-  MCP Spec:       ${chalk.underline("https://spec.modelcontextprotocol.io")}
+  Documentation:  ${chalk4.underline("https://github.com/d1maash/mcp-new")}
+  MCP Spec:       ${chalk4.underline("https://spec.modelcontextprotocol.io")}
 `;
-program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("1.2.1").addHelpText("beforeAll", logo).addHelpText("after", examples);
+program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("1.2.2").addHelpText("beforeAll", logo).addHelpText("after", examples);
 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("--preset <name>", "Use a preset template (database, rest-api, filesystem)").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").addHelpText("after", `
-${chalk.bold("Examples:")}
+${chalk4.bold("Examples:")}
 
-  ${chalk.gray("# Initialize in current directory")}
-  ${chalk.cyan("$")} mcp-new init
+  ${chalk4.gray("# Initialize in current directory")}
+  ${chalk4.cyan("$")} mcp-new init
 
-  ${chalk.gray("# Initialize with TypeScript")}
-  ${chalk.cyan("$")} mcp-new init -t
+  ${chalk4.gray("# Initialize with TypeScript")}
+  ${chalk4.cyan("$")} mcp-new init -t
 
-  ${chalk.gray("# Force initialize (overwrite existing files)")}
-  ${chalk.cyan("$")} mcp-new init -f
+  ${chalk4.gray("# Force initialize (overwrite existing files)")}
+  ${chalk4.cyan("$")} mcp-new init -f
 `).action(initCommand);
 program.command("add-tool").description("Add a new tool to an existing MCP server").option("-n, --name <name>", "Tool name (snake_case)").addHelpText("after", `
-${chalk.bold("Examples:")}
+${chalk4.bold("Examples:")}
 
-  ${chalk.gray("# Add tool interactively")}
-  ${chalk.cyan("$")} mcp-new add-tool
+  ${chalk4.gray("# Add tool interactively")}
+  ${chalk4.cyan("$")} mcp-new add-tool
 
-  ${chalk.gray("# Add tool with name")}
-  ${chalk.cyan("$")} mcp-new add-tool -n my_new_tool
+  ${chalk4.gray("# Add tool with name")}
+  ${chalk4.cyan("$")} mcp-new add-tool -n my_new_tool
 `).action(addToolCommand);
+program.command("list-presets").description("List all available preset templates").addHelpText("after", `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Show all presets with their tools")}
+  ${chalk4.cyan("$")} mcp-new list-presets
+`).action(listPresetsCommand);
+program.command("validate").description("Validate the current MCP server project").addHelpText("after", `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Validate current project")}
+  ${chalk4.cyan("$")} mcp-new validate
+
+${chalk4.bold("Checks:")}
+  \u2022 Project configuration (package.json, pyproject.toml, etc.)
+  \u2022 MCP SDK dependency presence and version
+  \u2022 Entry point file existence
+  \u2022 Basic project structure
+`).action(validateCommand);
+program.command("upgrade").description("Upgrade MCP SDK to the latest version").option("-c, --check", "Check for updates without installing").addHelpText("after", `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Upgrade MCP SDK to latest version")}
+  ${chalk4.cyan("$")} mcp-new upgrade
+
+  ${chalk4.gray("# Check for updates without installing")}
+  ${chalk4.cyan("$")} mcp-new upgrade --check
+
+${chalk4.bold("Supported languages:")}
+  \u2022 TypeScript/JavaScript (npm)
+  \u2022 Python (pip)
+  \u2022 Go (go modules)
+  \u2022 Rust (cargo)
+`).action(upgradeCommand);
 program.parse();
 if (process.argv.length === 2) {
   program.help();

package/dist/index.js

@@ -60,7 +60,7 @@ import {
   walkDir,
   withSpinner,
   writeFile
-} from "./chunk-BHGUGEHE.js";
+} from "./chunk-3JG4FVS2.js";
 
 // src/types/config.ts
 import { z } from "zod";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mcp-new",
-    "version": "1.2.1",
+    "version": "1.2.2",
     "description": "CLI generator for MCP servers. Like create-react-app, but for MCP.",
     "type": "module",
     "main": "./dist/index.js",