mcp-new 1.2.1 → 1.5.0

package/dist/cli.js

@@ -1,84 +1,850 @@
 #!/usr/bin/env node
 import {
+  PRESETS,
   addToolCommand,
   createCommand,
-  initCommand
-} from "./chunk-BHGUGEHE.js";
+  createInitialCommit,
+  createSpinner,
+  ensureDir,
+  exists,
+  generateFromWizard,
+  initCommand,
+  initGitRepository,
+  isGitInstalled,
+  logger,
+  promptJavaBuildTool,
+  promptLanguage,
+  readDir,
+  readFile,
+  withSpinner,
+  writeFile
+} from "./chunk-YISSMIHU.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/commands/monorepo.ts
+import path3 from "path";
+import inquirer from "inquirer";
+async function monorepoInitCommand(workspaceName, options) {
+  try {
+    let name = workspaceName;
+    if (!name) {
+      const { inputName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "inputName",
+          message: "Workspace name:",
+          default: "mcp-workspace"
+        }
+      ]);
+      name = inputName;
+    }
+    const outputDir = path3.resolve(process.cwd(), name);
+    if (await exists(outputDir)) {
+      const files = await readDir(outputDir);
+      if (files.length > 0 && !options.force) {
+        logger.error(
+          `Directory "${name}" already exists and is not empty. Use --force to override.`
+        );
+        process.exit(1);
+      }
+    }
+    logger.title(`Creating MCP Monorepo: ${name}`);
+    await withSpinner(
+      "Creating workspace structure...",
+      async () => {
+        await ensureDir(outputDir);
+        await ensureDir(path3.join(outputDir, "packages"));
+        await ensureDir(path3.join(outputDir, "shared"));
+      },
+      "Workspace structure created"
+    );
+    const workspaceConfig = {
+      name,
+      packages: []
+    };
+    await withSpinner(
+      "Creating configuration files...",
+      async () => {
+        await writeFile(
+          path3.join(outputDir, "mcp.workspace.json"),
+          JSON.stringify(workspaceConfig, null, 2)
+        );
+        const packageJson = {
+          name,
+          version: "1.0.0",
+          private: true,
+          workspaces: ["packages/*", "shared/*"],
+          scripts: {
+            build: "npm run build --workspaces",
+            dev: "npm run dev --workspaces --if-present",
+            test: "npm run test --workspaces --if-present"
+          }
+        };
+        await writeFile(path3.join(outputDir, "package.json"), JSON.stringify(packageJson, null, 2));
+        const readme = `# ${name}
+
+MCP Monorepo Workspace
+
+## Structure
+
+\`\`\`
+${name}/
+\u251C\u2500\u2500 packages/           # MCP servers
+\u251C\u2500\u2500 shared/             # Shared utilities and types
+\u251C\u2500\u2500 mcp.workspace.json  # Workspace configuration
+\u2514\u2500\u2500 package.json        # Root package.json
+\`\`\`
+
+## Commands
+
+\`\`\`bash
+# Add a new MCP server
+mcp-new monorepo add <server-name>
+
+# Build all packages
+npm run build
+
+# Run all dev servers
+npm run dev
+\`\`\`
+
+## Packages
+
+${workspaceConfig.packages.length === 0 ? "_No packages yet. Run `mcp-new monorepo add <name>` to create one._" : workspaceConfig.packages.map((p) => `- ${p}`).join("\n")}
+`;
+        await writeFile(path3.join(outputDir, "README.md"), readme);
+        const gitignore = `# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+`;
+        await writeFile(path3.join(outputDir, ".gitignore"), gitignore);
+      },
+      "Configuration files created"
+    );
+    const gitInstalled = await isGitInstalled();
+    if (gitInstalled) {
+      await withSpinner(
+        "Initializing git repository...",
+        async () => {
+          await initGitRepository(outputDir);
+          await createInitialCommit(outputDir);
+        },
+        "Git repository initialized"
+      );
+    }
+    logger.success(`Monorepo workspace "${name}" created successfully!`);
+    logger.box("Next steps:", ["", `  cd ${name}`, `  mcp-new monorepo add my-first-server`, ""]);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function monorepoAddCommand(serverName, options) {
+  try {
+    const workspaceConfigPath = path3.resolve(process.cwd(), "mcp.workspace.json");
+    if (!await exists(workspaceConfigPath)) {
+      logger.error(
+        "Not in a monorepo workspace. Run `mcp-new monorepo init` first, or cd into an existing workspace."
+      );
+      process.exit(1);
+    }
+    let name = serverName || options.name;
+    if (!name) {
+      const { inputName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "inputName",
+          message: "Server name:",
+          default: "my-mcp-server"
+        }
+      ]);
+      name = inputName;
+    }
+    let language;
+    const opts = options;
+    if (opts.typescript === true || opts.t === true) language = "typescript";
+    else if (opts.python === true || opts.p === true) language = "python";
+    else if (opts.go === true || opts.g === true) language = "go";
+    else if (opts.rust === true || opts.r === true) language = "rust";
+    else if (opts.java === true || opts.j === true) language = "java";
+    else if (opts.kotlin === true || opts.k === true) language = "kotlin";
+    else if (opts.csharp === true || opts.c === true) language = "csharp";
+    else if (opts.elixir === true || opts.e === true) language = "elixir";
+    if (!language) {
+      language = await promptLanguage();
+    }
+    let javaBuildTool;
+    if (language === "java" || language === "kotlin") {
+      javaBuildTool = options.maven ? "maven" : options.gradle ? "gradle" : await promptJavaBuildTool();
+    }
+    const outputDir = path3.join(process.cwd(), "packages", name);
+    if (await exists(outputDir)) {
+      logger.error(`Server "${name}" already exists in packages/`);
+      process.exit(1);
+    }
+    logger.title(`Adding MCP Server: ${name}`);
+    await generateFromWizard(
+      {
+        name,
+        description: "",
+        language,
+        transport: "stdio",
+        tools: [],
+        resources: [],
+        includeExampleTool: true,
+        skipInstall: options.skipInstall || false,
+        initGit: false,
+        // Don't init git for individual packages
+        javaBuildTool
+      },
+      outputDir
+    );
+    const workspaceConfigContent = await readFile(workspaceConfigPath);
+    const workspaceConfig = JSON.parse(workspaceConfigContent);
+    workspaceConfig.packages.push(name);
+    await writeFile(workspaceConfigPath, JSON.stringify(workspaceConfig, null, 2));
+    logger.success(`Server "${name}" added to packages/`);
+    logger.info(`Language: ${language}${javaBuildTool ? ` (${javaBuildTool})` : ""}`);
+    logger.box("Next steps:", [
+      "",
+      `  cd packages/${name}`,
+      "  # Start developing your MCP server",
+      ""
+    ]);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function monorepoListCommand() {
+  try {
+    const workspaceConfigPath = path3.resolve(process.cwd(), "mcp.workspace.json");
+    if (!await exists(workspaceConfigPath)) {
+      logger.error("Not in a monorepo workspace.");
+      process.exit(1);
+    }
+    const workspaceConfigContent = await readFile(workspaceConfigPath);
+    const workspaceConfig = JSON.parse(workspaceConfigContent);
+    logger.title(`Workspace: ${workspaceConfig.name}`);
+    if (workspaceConfig.packages.length === 0) {
+      logger.info("No packages yet. Run `mcp-new monorepo add <name>` to create one.");
+    } else {
+      logger.info("Packages:");
+      workspaceConfig.packages.forEach((pkg, index) => {
+        console.log(`  ${index + 1}. ${pkg}`);
+      });
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+// 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
+  ${chalk4.green("-j, --java")}         Java with Maven/Gradle
+  ${chalk4.green("-k, --kotlin")}       Kotlin with Maven/Gradle
+  ${chalk4.green("-c, --csharp")}       C# with .NET
+  ${chalk4.green("-e, --elixir")}       Elixir with Mix
 
-${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.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:")}
+program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("1.5.0").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("-j, --java", "Use Java template").option("-k, --kotlin", "Use Kotlin template").option("-c, --csharp", "Use C# (.NET) template").option("-e, --elixir", "Use Elixir template").option("--maven", "Use Maven build tool (for Java/Kotlin)").option("--gradle", "Use Gradle build tool (for Java/Kotlin)").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("-j, --java", "Use Java template").option("-k, --kotlin", "Use Kotlin template").option("-c, --csharp", "Use C# (.NET) template").option("-e, --elixir", "Use Elixir template").option("--maven", "Use Maven build tool (for Java/Kotlin)").option("--gradle", "Use Gradle build tool (for Java/Kotlin)").option("--skip-install", "Skip dependency installation").option("-f, --force", "Initialize even if directory contains files").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Initialize in current directory")}
+  ${chalk4.cyan("$")} mcp-new init
+
+  ${chalk4.gray("# Initialize with TypeScript")}
+  ${chalk4.cyan("$")} mcp-new init -t
+
+  ${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",
+  `
+${chalk4.bold("Examples:")}
+
+  ${chalk4.gray("# Add tool interactively")}
+  ${chalk4.cyan("$")} mcp-new add-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
 
-  ${chalk.gray("# Initialize in current directory")}
-  ${chalk.cyan("$")} mcp-new init
+${chalk4.bold("Supported languages:")}
+  \u2022 TypeScript/JavaScript (npm)
+  \u2022 Python (pip)
+  \u2022 Go (go modules)
+  \u2022 Rust (cargo)
+`
+).action(upgradeCommand);
+var monorepo = program.command("monorepo").description("Manage MCP monorepo workspaces");
+monorepo.command("init [workspace-name]").description("Initialize a new MCP monorepo workspace").option("-f, --force", "Initialize even if directory contains files").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
 
-  ${chalk.gray("# Initialize with TypeScript")}
-  ${chalk.cyan("$")} mcp-new init -t
+  ${chalk4.gray("# Create a new monorepo workspace")}
+  ${chalk4.cyan("$")} mcp-new monorepo init my-workspace
 
-  ${chalk.gray("# Force initialize (overwrite existing files)")}
-  ${chalk.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.gray("# Create in current directory name")}
+  ${chalk4.cyan("$")} mcp-new monorepo init
+`
+).action((_workspaceName, _options, command) => {
+  const opts = command.optsWithGlobals();
+  const workspaceName = command.args[0];
+  monorepoInitCommand(workspaceName, opts);
+});
+monorepo.command("add [server-name]").description("Add a new MCP server to the workspace").option("-n, --name <name>", "Server name").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("-j, --java", "Use Java template").option("-k, --kotlin", "Use Kotlin template").option("-c, --csharp", "Use C# (.NET) template").option("-e, --elixir", "Use Elixir template").option("--maven", "Use Maven build tool (for Java/Kotlin)").option("--gradle", "Use Gradle build tool (for Java/Kotlin)").option("--skip-install", "Skip dependency installation").addHelpText(
+  "after",
+  `
+${chalk4.bold("Examples:")}
 
-  ${chalk.gray("# Add tool interactively")}
-  ${chalk.cyan("$")} mcp-new add-tool
+  ${chalk4.gray("# Add a TypeScript server")}
+  ${chalk4.cyan("$")} mcp-new monorepo add my-server -t
 
-  ${chalk.gray("# Add tool with name")}
-  ${chalk.cyan("$")} mcp-new add-tool -n my_new_tool
-`).action(addToolCommand);
+  ${chalk4.gray("# Add a Java server with Gradle")}
+  ${chalk4.cyan("$")} mcp-new monorepo add api-server -j --gradle
+`
+).action((_serverName, _options, command) => {
+  const opts = command.optsWithGlobals();
+  const serverName = command.args[0];
+  monorepoAddCommand(serverName, opts);
+});
+monorepo.command("list").description("List all packages in the workspace").action(monorepoListCommand);
 program.parse();
 if (process.argv.length === 2) {
   program.help();