mcp-new 0.1.0

package/dist/chunk-QRUHMGU5.js

@@ -0,0 +1,1540 @@
+// src/utils/validator.ts
+var projectNameRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Project name cannot be empty" };
+  }
+  if (name.length > 214) {
+    return { valid: false, error: "Project name must be less than 214 characters" };
+  }
+  if (!projectNameRegex.test(name)) {
+    return {
+      valid: false,
+      error: "Project name must start and end with lowercase letter or number, and contain only lowercase letters, numbers, and hyphens"
+    };
+  }
+  const reservedNames = ["node_modules", "favicon.ico", "npm", "npx"];
+  if (reservedNames.includes(name.toLowerCase())) {
+    return { valid: false, error: `"${name}" is a reserved name` };
+  }
+  return { valid: true };
+}
+function validateToolName(name) {
+  if (!name || name.trim().length === 0) {
+    return { valid: false, error: "Tool name cannot be empty" };
+  }
+  const toolNameRegex = /^[a-z][a-z0-9_]*$/;
+  if (!toolNameRegex.test(name)) {
+    return {
+      valid: false,
+      error: "Tool name must start with a letter and contain only lowercase letters, numbers, and underscores"
+    };
+  }
+  return { valid: true };
+}
+function validateUrl(url) {
+  try {
+    new URL(url);
+    return { valid: true };
+  } catch {
+    return { valid: false, error: "Invalid URL format" };
+  }
+}
+function validateFilePath(path7) {
+  if (!path7 || path7.trim().length === 0) {
+    return { valid: false, error: "File path cannot be empty" };
+  }
+  const invalidChars = /[<>:"|?*]/;
+  if (invalidChars.test(path7)) {
+    return { valid: false, error: "File path contains invalid characters" };
+  }
+  return { valid: true };
+}
+function parseAndValidate(schema, data) {
+  return schema.parse(data);
+}
+function safeParseAndValidate(schema, data) {
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+
+// src/prompts/project-name.ts
+import inquirer from "inquirer";
+async function promptProjectName(defaultName) {
+  const { projectName } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "Project name:",
+      default: defaultName || "my-mcp-server",
+      validate: (input) => {
+        const result = validateProjectName(input);
+        return result.valid ? true : result.error || "Invalid project name";
+      }
+    }
+  ]);
+  return projectName;
+}
+async function promptProjectDescription() {
+  const { description } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "description",
+      message: "Project description (optional):",
+      default: ""
+    }
+  ]);
+  return description;
+}
+
+// src/prompts/language.ts
+import inquirer2 from "inquirer";
+async function promptLanguage() {
+  const { language } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "language",
+      message: "Select language:",
+      choices: [
+        { name: "TypeScript", value: "typescript" },
+        { name: "Python", value: "python" }
+      ],
+      default: "typescript"
+    }
+  ]);
+  return language;
+}
+
+// src/prompts/transport.ts
+import inquirer3 from "inquirer";
+async function promptTransport() {
+  const { transport } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "transport",
+      message: "Select transport:",
+      choices: [
+        { name: "stdio (standard input/output)", value: "stdio" },
+        { name: "SSE (Server-Sent Events)", value: "sse" }
+      ],
+      default: "stdio"
+    }
+  ]);
+  return transport;
+}
+
+// src/prompts/tools.ts
+import inquirer4 from "inquirer";
+async function promptIncludeExampleTool() {
+  const { includeExample } = await inquirer4.prompt([
+    {
+      type: "confirm",
+      name: "includeExample",
+      message: "Add example tool?",
+      default: true
+    }
+  ]);
+  return includeExample;
+}
+async function promptAddTools() {
+  const { addTools } = await inquirer4.prompt([
+    {
+      type: "confirm",
+      name: "addTools",
+      message: "Do you want to add custom tools?",
+      default: false
+    }
+  ]);
+  return addTools;
+}
+async function promptToolConfig() {
+  const { name, description } = await inquirer4.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Tool name (snake_case):",
+      validate: (input) => {
+        const result = validateToolName(input);
+        return result.valid ? true : result.error || "Invalid tool name";
+      }
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Tool description:",
+      validate: (input) => input.trim().length > 0 ? true : "Description is required"
+    }
+  ]);
+  const parameters = await promptToolParameters();
+  return { name, description, parameters };
+}
+async function promptToolParameters() {
+  const parameters = [];
+  let addMore = true;
+  while (addMore) {
+    const { shouldAdd } = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "shouldAdd",
+        message: parameters.length === 0 ? "Add parameter?" : "Add another parameter?",
+        default: parameters.length === 0
+      }
+    ]);
+    if (!shouldAdd) {
+      addMore = false;
+      continue;
+    }
+    const param = await promptSingleParameter();
+    parameters.push(param);
+  }
+  return parameters;
+}
+async function promptSingleParameter() {
+  const { name, type, description, required } = await inquirer4.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Parameter name:",
+      validate: (input) => input.trim().length > 0 ? true : "Parameter name is required"
+    },
+    {
+      type: "list",
+      name: "type",
+      message: "Parameter type:",
+      choices: [
+        { name: "string", value: "string" },
+        { name: "number", value: "number" },
+        { name: "boolean", value: "boolean" },
+        { name: "object", value: "object" },
+        { name: "array", value: "array" }
+      ]
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Parameter description:",
+      default: ""
+    },
+    {
+      type: "confirm",
+      name: "required",
+      message: "Required parameter?",
+      default: true
+    }
+  ]);
+  return { name, type, description, required };
+}
+async function promptMultipleTools() {
+  const tools = [];
+  let addMore = true;
+  while (addMore) {
+    const tool = await promptToolConfig();
+    tools.push(tool);
+    const { shouldAddMore } = await inquirer4.prompt([
+      {
+        type: "confirm",
+        name: "shouldAddMore",
+        message: "Add another tool?",
+        default: false
+      }
+    ]);
+    addMore = shouldAddMore;
+  }
+  return tools;
+}
+
+// src/prompts/resources.ts
+import inquirer5 from "inquirer";
+async function promptAddResources() {
+  const { addResources } = await inquirer5.prompt([
+    {
+      type: "confirm",
+      name: "addResources",
+      message: "Do you want to add resources?",
+      default: false
+    }
+  ]);
+  return addResources;
+}
+async function promptResourceConfig() {
+  const { name, uri, description, mimeType } = await inquirer5.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Resource name:",
+      validate: (input) => input.trim().length > 0 ? true : "Name is required"
+    },
+    {
+      type: "input",
+      name: "uri",
+      message: "Resource URI:",
+      validate: (input) => input.trim().length > 0 ? true : "URI is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Resource description:",
+      default: ""
+    },
+    {
+      type: "input",
+      name: "mimeType",
+      message: "MIME type (optional):",
+      default: ""
+    }
+  ]);
+  return {
+    name,
+    uri,
+    description,
+    mimeType: mimeType || void 0
+  };
+}
+async function promptMultipleResources() {
+  const resources = [];
+  let addMore = true;
+  while (addMore) {
+    const resource = await promptResourceConfig();
+    resources.push(resource);
+    const { shouldAddMore } = await inquirer5.prompt([
+      {
+        type: "confirm",
+        name: "shouldAddMore",
+        message: "Add another resource?",
+        default: false
+      }
+    ]);
+    addMore = shouldAddMore;
+  }
+  return resources;
+}
+
+// src/prompts/index.ts
+async function runWizard(options = {}) {
+  const name = await promptProjectName(options.defaultName);
+  let description = "";
+  if (!options.skipDescription) {
+    description = await promptProjectDescription();
+  }
+  const language = options.presetLanguage || await promptLanguage();
+  const transport = await promptTransport();
+  const includeExampleTool = await promptIncludeExampleTool();
+  let tools = [];
+  let resources = [];
+  if (!options.skipAdvanced) {
+    const wantTools = await promptAddTools();
+    if (wantTools) {
+      tools = await promptMultipleTools();
+    }
+    const wantResources = await promptAddResources();
+    if (wantResources) {
+      resources = await promptMultipleResources();
+    }
+  }
+  return {
+    name,
+    description,
+    language,
+    transport,
+    tools,
+    resources,
+    includeExampleTool,
+    skipInstall: false,
+    initGit: true
+  };
+}
+async function runQuickWizard(defaultName, presetLanguage) {
+  const name = await promptProjectName(defaultName);
+  const language = presetLanguage || await promptLanguage();
+  const transport = await promptTransport();
+  const includeExampleTool = await promptIncludeExampleTool();
+  return {
+    name,
+    description: "",
+    language,
+    transport,
+    tools: [],
+    resources: [],
+    includeExampleTool,
+    skipInstall: false,
+    initGit: true
+  };
+}
+
+// src/utils/file-system.ts
+import fs from "fs-extra";
+import path from "path";
+import ejs from "ejs";
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function writeFile(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+async function copyFile(src, dest) {
+  await fs.ensureDir(path.dirname(dest));
+  await fs.copyFile(src, dest);
+}
+async function copyDir(src, dest) {
+  await fs.copy(src, dest);
+}
+async function exists(filePath) {
+  return fs.pathExists(filePath);
+}
+async function remove(filePath) {
+  await fs.remove(filePath);
+}
+async function readDir(dirPath) {
+  return fs.readdir(dirPath);
+}
+async function isDirectory(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function renderTemplate(templatePath, data) {
+  const template = await readFile(templatePath);
+  return ejs.render(template, data, { async: false });
+}
+async function renderTemplateToFile(templatePath, outputPath, data) {
+  const content = await renderTemplate(templatePath, data);
+  const finalPath = outputPath.replace(/\.ejs$/, "");
+  await writeFile(finalPath, content);
+}
+async function walkDir(dirPath, callback) {
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dirPath, entry.name);
+    const isDir = entry.isDirectory();
+    await callback(fullPath, isDir);
+    if (isDir) {
+      await walkDir(fullPath, callback);
+    }
+  }
+}
+function getTemplateDir() {
+  const devPath = path.join(import.meta.dirname, "..", "templates");
+  const prodPath = path.join(import.meta.dirname, "..", "..", "templates");
+  if (fs.existsSync(devPath)) {
+    return devPath;
+  }
+  return prodPath;
+}
+function resolveOutputPath(basePath, ...segments) {
+  return path.resolve(basePath, ...segments);
+}
+
+// src/utils/git.ts
+import { execa } from "execa";
+import path2 from "path";
+async function isGitInstalled() {
+  try {
+    await execa("git", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initGitRepository(projectPath) {
+  const gitDir = path2.join(projectPath, ".git");
+  if (await exists(gitDir)) {
+    return;
+  }
+  await execa("git", ["init"], { cwd: projectPath });
+}
+async function createInitialCommit(projectPath) {
+  try {
+    await execa("git", ["add", "."], { cwd: projectPath });
+    await execa("git", ["commit", "-m", "Initial commit from create-mcp-server"], {
+      cwd: projectPath
+    });
+  } catch {
+  }
+}
+async function getGitUser() {
+  try {
+    const [nameResult, emailResult] = await Promise.all([
+      execa("git", ["config", "--get", "user.name"]).catch(() => ({ stdout: "" })),
+      execa("git", ["config", "--get", "user.email"]).catch(() => ({ stdout: "" }))
+    ]);
+    return {
+      name: nameResult.stdout.trim() || void 0,
+      email: emailResult.stdout.trim() || void 0
+    };
+  } catch {
+    return {};
+  }
+}
+async function isInsideGitRepository(dirPath) {
+  try {
+    await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dirPath });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => {
+    console.log(chalk.blue("i"), message);
+  },
+  success: (message) => {
+    console.log(chalk.green("\u2713"), message);
+  },
+  warning: (message) => {
+    console.log(chalk.yellow("\u26A0"), message);
+  },
+  error: (message) => {
+    console.log(chalk.red("\u2717"), message);
+  },
+  step: (step, total, message) => {
+    console.log(chalk.cyan(`[${step}/${total}]`), message);
+  },
+  title: (message) => {
+    console.log();
+    console.log(chalk.bold.white(message));
+    console.log(chalk.gray("\u2500".repeat(50)));
+  },
+  blank: () => {
+    console.log();
+  },
+  list: (items) => {
+    items.forEach((item) => {
+      console.log(chalk.gray("  \u2022"), item);
+    });
+  },
+  code: (code) => {
+    console.log(chalk.gray("  $"), chalk.cyan(code));
+  },
+  box: (title, content) => {
+    console.log();
+    console.log(chalk.green("\u250C\u2500"), chalk.bold.green(title));
+    content.forEach((line) => {
+      console.log(chalk.green("\u2502"), line);
+    });
+    console.log(chalk.green("\u2514\u2500"));
+  },
+  nextSteps: (projectName, language) => {
+    logger.blank();
+    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")}`,
+      ""
+    ]);
+  }
+};
+
+// src/utils/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  const spinner = ora({
+    text,
+    spinner: "dots"
+  });
+  return {
+    start: (newText) => {
+      if (newText) spinner.text = newText;
+      spinner.start();
+      return createSpinner(spinner.text);
+    },
+    stop: () => {
+      spinner.stop();
+      return createSpinner(spinner.text);
+    },
+    succeed: (newText) => {
+      spinner.succeed(newText);
+      return createSpinner(spinner.text);
+    },
+    fail: (newText) => {
+      spinner.fail(newText);
+      return createSpinner(spinner.text);
+    },
+    warn: (newText) => {
+      spinner.warn(newText);
+      return createSpinner(spinner.text);
+    },
+    info: (newText) => {
+      spinner.info(newText);
+      return createSpinner(spinner.text);
+    },
+    get text() {
+      return spinner.text;
+    },
+    set text(value) {
+      spinner.text = value;
+    }
+  };
+}
+async function withSpinner(text, fn, successText, failText) {
+  const spinner = ora({
+    text,
+    spinner: "dots"
+  }).start();
+  try {
+    const result = await fn();
+    spinner.succeed(successText || text);
+    return result;
+  } catch (error) {
+    spinner.fail(failText || `Failed: ${text}`);
+    throw error;
+  }
+}
+
+// src/generators/base.ts
+import path3 from "path";
+import { execa as execa2 } from "execa";
+var BaseGenerator = class {
+  config;
+  outputDir;
+  templateDir;
+  constructor(context) {
+    this.config = context.config;
+    this.outputDir = context.outputDir;
+    this.templateDir = context.templateDir;
+  }
+  async createProjectStructure() {
+    await ensureDir(this.outputDir);
+    await ensureDir(path3.join(this.outputDir, "src"));
+  }
+  async renderTemplates() {
+    const templateData = this.getTemplateData();
+    await walkDir(this.templateDir, async (filePath, isDir) => {
+      if (isDir) return;
+      const relativePath = path3.relative(this.templateDir, filePath);
+      const outputPath = path3.join(this.outputDir, relativePath);
+      if (filePath.endsWith(".ejs")) {
+        await renderTemplateToFile(filePath, outputPath, templateData);
+      } else {
+        await copyFile(filePath, outputPath);
+      }
+    });
+  }
+  getTemplateData() {
+    return {
+      name: this.config.name,
+      description: this.config.description,
+      language: this.config.language,
+      transport: this.config.transport,
+      tools: this.config.tools,
+      resources: this.config.resources,
+      includeExampleTool: this.config.includeExampleTool
+    };
+  }
+  async installDependencies() {
+    if (this.config.skipInstall) {
+      logger.info("Skipping dependency installation (--skip-install)");
+      return;
+    }
+    const isTypescript = this.config.language === "typescript";
+    if (isTypescript) {
+      await this.installNodeDependencies();
+    } else {
+      await this.installPythonDependencies();
+    }
+  }
+  async installNodeDependencies() {
+    await withSpinner(
+      "Installing dependencies...",
+      async () => {
+        await execa2("npm", ["install"], { cwd: this.outputDir });
+      },
+      "Dependencies installed",
+      "Failed to install dependencies"
+    );
+  }
+  async installPythonDependencies() {
+    const hasPip = await this.checkCommand("pip");
+    const hasPip3 = await this.checkCommand("pip3");
+    if (!hasPip && !hasPip3) {
+      logger.warning("pip not found. Please install dependencies manually:");
+      logger.code("pip install -r requirements.txt");
+      return;
+    }
+    const pipCommand = hasPip3 ? "pip3" : "pip";
+    await withSpinner(
+      "Installing dependencies...",
+      async () => {
+        await execa2(pipCommand, ["install", "-r", "requirements.txt"], {
+          cwd: this.outputDir
+        });
+      },
+      "Dependencies installed",
+      "Failed to install dependencies"
+    );
+  }
+  async checkCommand(command) {
+    try {
+      await execa2("which", [command]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async initializeGit() {
+    if (!this.config.initGit) {
+      return;
+    }
+    const gitInstalled = await isGitInstalled();
+    if (!gitInstalled) {
+      logger.warning("Git not found. Skipping git initialization.");
+      return;
+    }
+    await withSpinner(
+      "Initializing git repository...",
+      async () => {
+        await initGitRepository(this.outputDir);
+        await createInitialCommit(this.outputDir);
+      },
+      "Git repository initialized",
+      "Failed to initialize git"
+    );
+  }
+  async checkOutputDir() {
+    if (await exists(this.outputDir)) {
+      const files = await readDir(this.outputDir);
+      if (files.length > 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+function createGeneratorContext(config, outputPath) {
+  const outputDir = outputPath || path3.resolve(process.cwd(), config.name);
+  const templateDir = path3.join(getTemplateDir(), config.language);
+  return {
+    config,
+    outputDir,
+    templateDir
+  };
+}
+
+// src/generators/from-wizard.ts
+var WizardGenerator = class extends BaseGenerator {
+  constructor(context) {
+    super(context);
+  }
+  async generate() {
+    logger.title(`Creating ${this.config.name}`);
+    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.nextSteps(this.config.name, this.config.language);
+  }
+};
+async function generateFromWizard(config, outputPath) {
+  const context = createGeneratorContext(config, outputPath);
+  const generator = new WizardGenerator(context);
+  await generator.generate();
+}
+
+// src/parsers/openapi.ts
+import YAML from "yaml";
+import inquirer6 from "inquirer";
+async function parseOpenAPISpec(content) {
+  let spec;
+  try {
+    spec = YAML.parse(content);
+  } catch {
+    throw new Error("Failed to parse OpenAPI specification. Ensure it is valid YAML or JSON.");
+  }
+  if (!spec.openapi && !("swagger" in spec)) {
+    throw new Error('Invalid OpenAPI specification. Missing "openapi" or "swagger" field.');
+  }
+  const endpoints = [];
+  for (const [path7, pathItem] of Object.entries(spec.paths)) {
+    const methods = ["get", "post", "put", "delete", "patch", "options", "head"];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const endpoint = parseOperation(path7, method, operation, spec);
+      endpoints.push(endpoint);
+    }
+  }
+  return endpoints;
+}
+function parseOperation(path7, method, operation, spec) {
+  const parameters = [];
+  if (operation.parameters) {
+    for (const param of operation.parameters) {
+      const resolvedParam = resolveRef(param, spec);
+      parameters.push({
+        name: resolvedParam.name,
+        in: resolvedParam.in,
+        type: resolvedParam.schema?.type || "string",
+        description: resolvedParam.description || "",
+        required: resolvedParam.required || false
+      });
+    }
+  }
+  if (operation.requestBody) {
+    const content = operation.requestBody.content;
+    const jsonContent = content?.["application/json"];
+    if (jsonContent?.schema) {
+      const schema = resolveRef(jsonContent.schema, spec);
+      const bodyParams = extractSchemaParameters(schema, spec, operation.requestBody.required);
+      parameters.push(...bodyParams);
+    }
+  }
+  return {
+    path: path7,
+    method: method.toUpperCase(),
+    operationId: operation.operationId || "",
+    summary: operation.summary || "",
+    description: operation.description || "",
+    parameters,
+    tags: operation.tags || []
+  };
+}
+function extractSchemaParameters(schema, spec, parentRequired = false) {
+  const parameters = [];
+  if (schema.properties) {
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const resolved = resolveRef(propSchema, spec);
+      const isRequired = parentRequired && (schema.required?.includes(name) ?? false);
+      parameters.push({
+        name,
+        in: "body",
+        type: resolved.type || "string",
+        description: resolved.description || "",
+        required: isRequired
+      });
+    }
+  }
+  return parameters;
+}
+function resolveRef(obj, spec) {
+  if (!obj || typeof obj !== "object") {
+    return obj;
+  }
+  const refObj = obj;
+  if (!refObj.$ref) {
+    return obj;
+  }
+  const refPath = refObj.$ref.replace("#/", "").split("/");
+  let resolved = spec;
+  for (const part of refPath) {
+    resolved = resolved[part];
+    if (!resolved) {
+      throw new Error(`Could not resolve reference: ${refObj.$ref}`);
+    }
+  }
+  return resolved;
+}
+async function selectEndpoints(endpoints) {
+  if (endpoints.length === 0) {
+    return [];
+  }
+  const choices = endpoints.map((ep) => ({
+    name: `${ep.method} ${ep.path} - ${ep.summary || ep.description || "No description"}`,
+    value: ep,
+    checked: true
+  }));
+  const { selected } = await inquirer6.prompt([
+    {
+      type: "checkbox",
+      name: "selected",
+      message: "Select endpoints to generate tools for:",
+      choices,
+      pageSize: 15
+    }
+  ]);
+  return selected;
+}
+function endpointToMCPTool(endpoint) {
+  const properties = {};
+  const required = [];
+  for (const param of endpoint.parameters) {
+    properties[param.name] = {
+      type: param.type,
+      description: param.description
+    };
+    if (param.required) {
+      required.push(param.name);
+    }
+  }
+  return {
+    name: endpoint.operationId || `${endpoint.method.toLowerCase()}_${endpoint.path.replace(/\//g, "_")}`,
+    description: endpoint.summary || endpoint.description,
+    inputSchema: {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : void 0
+    }
+  };
+}
+
+// src/generators/from-openapi.ts
+var OpenAPIGenerator = class extends BaseGenerator {
+  _endpoints = [];
+  constructor(context) {
+    super(context);
+  }
+  get endpoints() {
+    return this._endpoints;
+  }
+  async generate() {
+    logger.title(`Creating ${this.config.name} from OpenAPI`);
+    const isSafe = await this.checkOutputDir();
+    if (!isSafe) {
+      throw new Error(
+        `Directory ${this.outputDir} already exists and is not empty.`
+      );
+    }
+    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(`Generated ${this.config.tools.length} tools from OpenAPI spec`);
+    logger.nextSteps(this.config.name, this.config.language);
+  }
+  setEndpoints(endpoints) {
+    this._endpoints = endpoints;
+  }
+};
+async function generateFromOpenAPI(specPath, baseConfig) {
+  logger.info("Parsing OpenAPI specification...");
+  const specContent = await readFile(specPath);
+  const endpoints = await parseOpenAPISpec(specContent);
+  logger.info(`Found ${endpoints.length} endpoints`);
+  const selectedEndpoints = await selectEndpoints(endpoints);
+  if (selectedEndpoints.length === 0) {
+    throw new Error("No endpoints selected");
+  }
+  const tools = selectedEndpoints.map((endpoint) => ({
+    name: endpointToToolName(endpoint),
+    description: endpoint.summary || endpoint.description || `${endpoint.method.toUpperCase()} ${endpoint.path}`,
+    parameters: endpoint.parameters.map((param) => ({
+      name: param.name,
+      type: mapOpenAPIType(param.type),
+      description: param.description,
+      required: param.required
+    }))
+  }));
+  const config = {
+    name: baseConfig.name || "mcp-server",
+    description: baseConfig.description || "",
+    language: baseConfig.language || "typescript",
+    transport: baseConfig.transport || "stdio",
+    tools,
+    resources: [],
+    includeExampleTool: false,
+    skipInstall: baseConfig.skipInstall || false,
+    initGit: baseConfig.initGit !== false
+  };
+  const context = createGeneratorContext(config);
+  const generator = new OpenAPIGenerator(context);
+  generator.setEndpoints(selectedEndpoints);
+  await generator.generate();
+}
+function endpointToToolName(endpoint) {
+  if (endpoint.operationId) {
+    return endpoint.operationId.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").toLowerCase();
+  }
+  const method = endpoint.method.toLowerCase();
+  const pathParts = endpoint.path.split("/").filter((p) => p && !p.startsWith("{")).map((p) => p.replace(/[^a-zA-Z0-9]/g, ""));
+  return `${method}_${pathParts.join("_")}`.toLowerCase();
+}
+function mapOpenAPIType(type) {
+  switch (type.toLowerCase()) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    default:
+      return "string";
+  }
+}
+
+// src/generators/from-prompt.ts
+import Anthropic from "@anthropic-ai/sdk";
+import inquirer7 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.
+
+For each tool, provide:
+1. name: A snake_case name for the tool
+2. description: A clear description of what the tool does
+3. parameters: An array of parameters, each with:
+   - name: Parameter name
+   - type: One of: string, number, boolean, object, array
+   - description: What the parameter is for
+   - required: Whether it's required (true/false)
+
+Respond with a JSON array of tools. Example:
+[
+  {
+    "name": "create_page",
+    "description": "Creates a new page in the workspace",
+    "parameters": [
+      {"name": "title", "type": "string", "description": "Page title", "required": true},
+      {"name": "content", "type": "string", "description": "Page content in markdown", "required": false}
+    ]
+  }
+]`;
+var PromptGenerator = class extends BaseGenerator {
+  constructor(context) {
+    super(context);
+  }
+  async generate() {
+    logger.title(`Creating ${this.config.name}`);
+    const isSafe = await this.checkOutputDir();
+    if (!isSafe) {
+      throw new Error(
+        `Directory ${this.outputDir} already exists and is not empty.`
+      );
+    }
+    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(`Generated ${this.config.tools.length} tools from your description`);
+    logger.nextSteps(this.config.name, this.config.language);
+  }
+};
+async function generateFromPrompt(baseConfig) {
+  const { description } = await inquirer7.prompt([
+    {
+      type: "editor",
+      name: "description",
+      message: "Describe your API (opens editor):"
+    }
+  ]);
+  if (!description.trim()) {
+    throw new Error("Description cannot be empty");
+  }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "ANTHROPIC_API_KEY environment variable is required for AI generation. Get your API key at https://console.anthropic.com/"
+    );
+  }
+  let tools = [];
+  await withSpinner(
+    "Generating tools with Claude...",
+    async () => {
+      const anthropic = new Anthropic({ apiKey });
+      const message = await anthropic.messages.create({
+        model: "claude-3-5-sonnet-20241022",
+        max_tokens: 4096,
+        system: SYSTEM_PROMPT,
+        messages: [
+          {
+            role: "user",
+            content: description
+          }
+        ]
+      });
+      const content = message.content[0];
+      if (content.type !== "text") {
+        throw new Error("Unexpected response from Claude");
+      }
+      try {
+        tools = JSON.parse(content.text);
+      } catch {
+        const jsonMatch = content.text.match(/\[[\s\S]*\]/);
+        if (jsonMatch) {
+          tools = JSON.parse(jsonMatch[0]);
+        } else {
+          throw new Error("Could not parse tools from Claude response");
+        }
+      }
+    },
+    "Tools generated",
+    "Failed to generate tools"
+  );
+  logger.blank();
+  logger.info("Generated tools:");
+  tools.forEach((tool, index) => {
+    logger.list([`${index + 1}. ${tool.name} - ${tool.description}`]);
+  });
+  logger.blank();
+  const { confirm } = await inquirer7.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "Proceed with these tools?",
+      default: true
+    }
+  ]);
+  if (!confirm) {
+    throw new Error("Generation cancelled by user");
+  }
+  const config = {
+    name: baseConfig.name || "mcp-server",
+    description: baseConfig.description || description.slice(0, 100),
+    language: baseConfig.language || "typescript",
+    transport: baseConfig.transport || "stdio",
+    tools,
+    resources: [],
+    includeExampleTool: false,
+    skipInstall: baseConfig.skipInstall || false,
+    initGit: baseConfig.initGit !== false
+  };
+  const context = createGeneratorContext(config);
+  const generator = new PromptGenerator(context);
+  await generator.generate();
+}
+
+// src/commands/create.ts
+import path4 from "path";
+async function createCommand(projectName, options) {
+  try {
+    if (options.fromOpenapi) {
+      await handleOpenAPIGeneration(projectName, options);
+      return;
+    }
+    if (options.fromPrompt) {
+      await handlePromptGeneration(projectName, options);
+      return;
+    }
+    await handleWizardGeneration(projectName, options);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function handleWizardGeneration(projectName, options) {
+  let config;
+  const presetLanguage = options.typescript ? "typescript" : options.python ? "python" : void 0;
+  if (options.yes) {
+    config = await runQuickWizard(projectName, presetLanguage);
+  } else {
+    config = await runWizard({ defaultName: projectName, presetLanguage });
+  }
+  if (options.skipInstall) {
+    config.skipInstall = true;
+  }
+  const outputPath = path4.resolve(process.cwd(), config.name);
+  if (await exists(outputPath)) {
+    const files = await import("fs-extra").then((m) => m.readdir(outputPath));
+    if (files.length > 0) {
+      logger.error(`Directory "${config.name}" already exists and is not empty.`);
+      process.exit(1);
+    }
+  }
+  await generateFromWizard(config);
+}
+async function handleOpenAPIGeneration(projectName, options) {
+  const specPath = options.fromOpenapi;
+  if (!await exists(specPath)) {
+    logger.error(`OpenAPI specification file not found: ${specPath}`);
+    process.exit(1);
+  }
+  const name = projectName || path4.basename(specPath, path4.extname(specPath)) + "-mcp";
+  await generateFromOpenAPI(specPath, {
+    name,
+    language: options.typescript ? "typescript" : options.python ? "python" : void 0,
+    skipInstall: options.skipInstall
+  });
+}
+async function handlePromptGeneration(projectName, options) {
+  await generateFromPrompt({
+    name: projectName,
+    language: options.typescript ? "typescript" : options.python ? "python" : void 0,
+    skipInstall: options.skipInstall
+  });
+}
+
+// src/commands/init.ts
+import path5 from "path";
+import inquirer8 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([
+        {
+          type: "confirm",
+          name: "proceed",
+          message: "This directory already contains a project. Initialize MCP server here anyway?",
+          default: false
+        }
+      ]);
+      if (!proceed) {
+        logger.info("Initialization cancelled.");
+        return;
+      }
+    }
+    let language;
+    if (options.typescript) {
+      language = "typescript";
+    } else if (options.python) {
+      language = "python";
+    } 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 {
+      language = await promptLanguage();
+    }
+    const transport = await promptTransport();
+    const includeExampleTool = await promptIncludeExampleTool();
+    let projectName = dirName;
+    if (hasPackageJson) {
+      try {
+        const pkgContent = await readFile(path5.join(currentDir, "package.json"));
+        const pkg = JSON.parse(pkgContent);
+        projectName = pkg.name || dirName;
+      } catch {
+      }
+    }
+    const config = {
+      name: projectName,
+      description: "",
+      language,
+      transport,
+      tools: [],
+      resources: [],
+      includeExampleTool,
+      skipInstall: options.skipInstall || false,
+      initGit: false
+      // Don't init git in existing project
+    };
+    await generateFromWizard(config, currentDir);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/add-tool.ts
+import path6 from "path";
+async function addToolCommand(options) {
+  try {
+    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) {
+      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);
+    }
+    let tool;
+    if (options.name) {
+      tool = {
+        name: options.name,
+        description: `Tool ${options.name}`,
+        parameters: []
+      };
+      logger.info(`Creating tool: ${options.name}`);
+    } else {
+      tool = await promptToolConfig();
+    }
+    if (isTypeScript) {
+      await addToolToTypeScript(currentDir, tool);
+    } else {
+      await addToolToPython(currentDir, tool);
+    }
+    logger.success(`Tool "${tool.name}" added successfully!`);
+    logger.info("Remember to implement the tool logic in the generated file.");
+  } catch (error) {
+    if (error instanceof Error) {
+      logger.error(error.message);
+    } else {
+      logger.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+async function addToolToTypeScript(projectDir, tool) {
+  const toolsDir = path6.join(projectDir, "src", "tools");
+  const toolFileName = `${tool.name.replace(/_/g, "-")}.ts`;
+  const toolFilePath = path6.join(toolsDir, toolFileName);
+  if (await exists(toolFilePath)) {
+    logger.error(`Tool file already exists: ${toolFilePath}`);
+    process.exit(1);
+  }
+  const content = generateTypeScriptToolFile(tool);
+  await writeFile(toolFilePath, content);
+  logger.info(`Created: src/tools/${toolFileName}`);
+  logger.blank();
+  logger.info("Next steps:");
+  logger.list([
+    `Implement the tool logic in src/tools/${toolFileName}`,
+    "Import and register the tool in src/index.ts"
+  ]);
+}
+async function addToolToPython(projectDir, tool) {
+  const toolsDir = path6.join(projectDir, "src", "tools");
+  const toolFileName = `${tool.name}.py`;
+  const toolFilePath = path6.join(toolsDir, toolFileName);
+  if (await exists(toolFilePath)) {
+    logger.error(`Tool file already exists: ${toolFilePath}`);
+    process.exit(1);
+  }
+  const content = generatePythonToolFile(tool);
+  await writeFile(toolFilePath, content);
+  logger.info(`Created: src/tools/${toolFileName}`);
+  logger.blank();
+  logger.info("Next steps:");
+  logger.list([
+    `Implement the tool logic in src/tools/${toolFileName}`,
+    "Import and register the tool in src/server.py"
+  ]);
+}
+function generateTypeScriptToolFile(tool) {
+  const interfaceProps = tool.parameters.map((p) => `  ${p.name}${p.required ? "" : "?"}: ${mapTypeToTS(p.type)};`).join("\n");
+  const schemaProps = tool.parameters.map(
+    (p) => `          ${p.name}: {
+            type: "${p.type}",
+            description: "${p.description}",
+          },`
+  ).join("\n");
+  const required = tool.parameters.filter((p) => p.required).map((p) => `"${p.name}"`).join(", ");
+  return `/**
+ * ${tool.description}
+ */
+
+export interface ${toPascalCase(tool.name)}Input {
+${interfaceProps || "  // No parameters"}
+}
+
+export interface ${toPascalCase(tool.name)}Output {
+  result: string;
+}
+
+export async function ${toCamelCase(tool.name)}(
+  input: ${toPascalCase(tool.name)}Input
+): Promise<${toPascalCase(tool.name)}Output> {
+  // TODO: Implement tool logic
+  return {
+    result: \`${tool.name} executed with: \${JSON.stringify(input)}\`,
+  };
+}
+
+export const ${toCamelCase(tool.name)}Schema = {
+  name: "${tool.name}",
+  description: "${tool.description}",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+${schemaProps}
+    },
+    required: [${required}],
+  },
+};
+`;
+}
+function generatePythonToolFile(tool) {
+  const imports = tool.parameters.length > 0 ? "from dataclasses import dataclass\n" : "";
+  const fields = tool.parameters.map((p) => `    ${p.name}: ${mapTypeToPython(p.type)}`).join("\n");
+  const schemaProps = tool.parameters.map(
+    (p) => `                "${p.name}": {
+                    "type": "${p.type}",
+                    "description": "${p.description}",
+                },`
+  ).join("\n");
+  const required = tool.parameters.filter((p) => p.required).map((p) => `"${p.name}"`).join(", ");
+  return `"""
+${tool.description}
+"""
+
+${imports}from mcp.types import Tool
+
+
+@dataclass
+class ${toPascalCase(tool.name)}Input:
+${fields || "    pass"}
+
+
+@dataclass
+class ${toPascalCase(tool.name)}Output:
+    result: str
+
+
+async def ${tool.name}(input_data: ${toPascalCase(tool.name)}Input) -> ${toPascalCase(tool.name)}Output:
+    """
+    ${tool.description}
+    """
+    # TODO: Implement tool logic
+    return ${toPascalCase(tool.name)}Output(
+        result=f"${tool.name} executed with: {input_data}"
+    )
+
+
+${tool.name.toUpperCase()}_SCHEMA = Tool(
+    name="${tool.name}",
+    description="${tool.description}",
+    inputSchema={
+        "type": "object",
+        "properties": {
+${schemaProps}
+        },
+        "required": [${required}],
+    },
+)
+`;
+}
+function toPascalCase(str) {
+  return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function mapTypeToTS(type) {
+  switch (type) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "unknown[]";
+    case "object":
+      return "Record<string, unknown>";
+    default:
+      return "string";
+  }
+}
+function mapTypeToPython(type) {
+  switch (type) {
+    case "number":
+      return "float";
+    case "boolean":
+      return "bool";
+    case "array":
+      return "list";
+    case "object":
+      return "dict";
+    default:
+      return "str";
+  }
+}
+
+export {
+  projectNameRegex,
+  validateProjectName,
+  validateToolName,
+  validateUrl,
+  validateFilePath,
+  parseAndValidate,
+  safeParseAndValidate,
+  promptProjectName,
+  promptProjectDescription,
+  promptLanguage,
+  promptTransport,
+  promptIncludeExampleTool,
+  promptAddTools,
+  promptToolConfig,
+  promptMultipleTools,
+  promptAddResources,
+  promptResourceConfig,
+  promptMultipleResources,
+  runWizard,
+  runQuickWizard,
+  ensureDir,
+  writeFile,
+  readFile,
+  copyFile,
+  copyDir,
+  exists,
+  remove,
+  readDir,
+  isDirectory,
+  renderTemplate,
+  renderTemplateToFile,
+  walkDir,
+  getTemplateDir,
+  resolveOutputPath,
+  isGitInstalled,
+  initGitRepository,
+  createInitialCommit,
+  getGitUser,
+  isInsideGitRepository,
+  logger,
+  createSpinner,
+  withSpinner,
+  BaseGenerator,
+  createGeneratorContext,
+  WizardGenerator,
+  generateFromWizard,
+  parseOpenAPISpec,
+  selectEndpoints,
+  endpointToMCPTool,
+  OpenAPIGenerator,
+  generateFromOpenAPI,
+  PromptGenerator,
+  generateFromPrompt,
+  createCommand,
+  initCommand,
+  addToolCommand
+};