mcp-new 0.1.0

package/dist/index.js

@@ -0,0 +1,351 @@
+import {
+  BaseGenerator,
+  OpenAPIGenerator,
+  PromptGenerator,
+  WizardGenerator,
+  addToolCommand,
+  copyDir,
+  copyFile,
+  createCommand,
+  createGeneratorContext,
+  createInitialCommit,
+  createSpinner,
+  endpointToMCPTool,
+  ensureDir,
+  exists,
+  generateFromOpenAPI,
+  generateFromPrompt,
+  generateFromWizard,
+  getGitUser,
+  getTemplateDir,
+  initCommand,
+  initGitRepository,
+  isDirectory,
+  isGitInstalled,
+  isInsideGitRepository,
+  logger,
+  parseAndValidate,
+  parseOpenAPISpec,
+  projectNameRegex,
+  promptAddResources,
+  promptAddTools,
+  promptIncludeExampleTool,
+  promptLanguage,
+  promptMultipleResources,
+  promptMultipleTools,
+  promptProjectDescription,
+  promptProjectName,
+  promptResourceConfig,
+  promptToolConfig,
+  promptTransport,
+  readDir,
+  readFile,
+  remove,
+  renderTemplate,
+  renderTemplateToFile,
+  resolveOutputPath,
+  runQuickWizard,
+  runWizard,
+  safeParseAndValidate,
+  selectEndpoints,
+  validateFilePath,
+  validateProjectName,
+  validateToolName,
+  validateUrl,
+  walkDir,
+  withSpinner,
+  writeFile
+} from "./chunk-QRUHMGU5.js";
+
+// src/types/config.ts
+import { z } from "zod";
+var LanguageSchema = z.enum(["typescript", "python"]);
+var TransportSchema = z.enum(["stdio", "sse"]);
+var ToolParameterSchema = z.object({
+  name: z.string(),
+  type: z.enum(["string", "number", "boolean", "object", "array"]),
+  description: z.string(),
+  required: z.boolean().default(true)
+});
+var ToolConfigSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  parameters: z.array(ToolParameterSchema).default([])
+});
+var ResourceConfigSchema = z.object({
+  name: z.string(),
+  uri: z.string(),
+  description: z.string(),
+  mimeType: z.string().optional()
+});
+var ProjectConfigSchema = z.object({
+  name: z.string().min(1, "Project name is required"),
+  description: z.string().default(""),
+  language: LanguageSchema,
+  transport: TransportSchema,
+  tools: z.array(ToolConfigSchema).default([]),
+  resources: z.array(ResourceConfigSchema).default([]),
+  includeExampleTool: z.boolean().default(true),
+  skipInstall: z.boolean().default(false),
+  initGit: z.boolean().default(true)
+});
+
+// src/parsers/swagger.ts
+import YAML from "yaml";
+async function parseSwaggerSpec(content) {
+  let spec;
+  try {
+    spec = YAML.parse(content);
+  } catch {
+    throw new Error("Failed to parse Swagger specification.");
+  }
+  if (!spec.swagger || !spec.swagger.startsWith("2.")) {
+    throw new Error("Invalid Swagger specification. Expected swagger version 2.x");
+  }
+  const endpoints = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    const methods = ["get", "post", "put", "delete", "patch"];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const parameters = [];
+      if (operation.parameters) {
+        for (const param of operation.parameters) {
+          if (param.in === "body" && param.schema) {
+            const bodyParams = extractSwaggerBodyParams(param.schema, spec.definitions);
+            parameters.push(...bodyParams);
+          } else {
+            parameters.push({
+              name: param.name,
+              in: param.in,
+              type: param.type || "string",
+              description: param.description || "",
+              required: param.required || false
+            });
+          }
+        }
+      }
+      endpoints.push({
+        path,
+        method: method.toUpperCase(),
+        operationId: operation.operationId || "",
+        summary: operation.summary || "",
+        description: operation.description || "",
+        parameters,
+        tags: operation.tags || []
+      });
+    }
+  }
+  return endpoints;
+}
+function extractSwaggerBodyParams(schema, definitions) {
+  const parameters = [];
+  if (schema.$ref && definitions) {
+    const refName = schema.$ref.replace("#/definitions/", "");
+    const resolved = definitions[refName];
+    if (resolved) {
+      schema = resolved;
+    }
+  }
+  if (schema.properties) {
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      let resolvedProp = propSchema;
+      if (propSchema.$ref && definitions) {
+        const refName = propSchema.$ref.replace("#/definitions/", "");
+        resolvedProp = definitions[refName] || propSchema;
+      }
+      parameters.push({
+        name,
+        in: "body",
+        type: resolvedProp.type || "string",
+        description: "",
+        required: schema.required?.includes(name) || false
+      });
+    }
+  }
+  return parameters;
+}
+
+// src/parsers/postman.ts
+async function parsePostmanCollection(content) {
+  let collection;
+  try {
+    collection = JSON.parse(content);
+  } catch {
+    throw new Error("Failed to parse Postman collection. Ensure it is valid JSON.");
+  }
+  if (!collection.info?.schema?.includes("postman")) {
+    throw new Error("Invalid Postman collection format.");
+  }
+  const endpoints = [];
+  extractItemsRecursively(collection.item, endpoints);
+  return endpoints;
+}
+function extractItemsRecursively(items, endpoints) {
+  for (const item of items) {
+    if (item.item) {
+      extractItemsRecursively(item.item, endpoints);
+      continue;
+    }
+    if (item.request) {
+      const endpoint = parsePostmanRequest(item.name, item.request);
+      if (endpoint) {
+        endpoints.push(endpoint);
+      }
+    }
+  }
+}
+function parsePostmanRequest(name, request) {
+  const parameters = [];
+  let path = "/";
+  if (typeof request.url === "string") {
+    try {
+      const url = new URL(request.url);
+      path = url.pathname;
+    } catch {
+      path = request.url;
+    }
+  } else if (request.url) {
+    path = "/" + (request.url.path?.join("/") || "");
+    if (request.url.query) {
+      for (const query of request.url.query) {
+        if (query.disabled) continue;
+        parameters.push({
+          name: query.key,
+          in: "query",
+          type: "string",
+          description: query.description || "",
+          required: false
+        });
+      }
+    }
+    if (request.url.variable) {
+      for (const variable of request.url.variable) {
+        parameters.push({
+          name: variable.key,
+          in: "path",
+          type: "string",
+          description: variable.description || "",
+          required: true
+        });
+      }
+    }
+  }
+  if (request.body) {
+    if (request.body.mode === "urlencoded" && request.body.urlencoded) {
+      for (const param of request.body.urlencoded) {
+        parameters.push({
+          name: param.key,
+          in: "body",
+          type: param.type || "string",
+          description: param.description || "",
+          required: false
+        });
+      }
+    } else if (request.body.mode === "formdata" && request.body.formdata) {
+      for (const param of request.body.formdata) {
+        parameters.push({
+          name: param.key,
+          in: "body",
+          type: param.type || "string",
+          description: param.description || "",
+          required: false
+        });
+      }
+    } else if (request.body.mode === "raw" && request.body.raw) {
+      try {
+        const body = JSON.parse(request.body.raw);
+        if (typeof body === "object" && body !== null) {
+          for (const key of Object.keys(body)) {
+            parameters.push({
+              name: key,
+              in: "body",
+              type: typeof body[key],
+              description: "",
+              required: false
+            });
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return {
+    path,
+    method: request.method.toUpperCase(),
+    operationId: nameToOperationId(name),
+    summary: name,
+    description: request.description || "",
+    parameters,
+    tags: []
+  };
+}
+function nameToOperationId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+export {
+  BaseGenerator,
+  LanguageSchema,
+  OpenAPIGenerator,
+  ProjectConfigSchema,
+  PromptGenerator,
+  ResourceConfigSchema,
+  ToolConfigSchema,
+  ToolParameterSchema,
+  TransportSchema,
+  WizardGenerator,
+  addToolCommand,
+  copyDir,
+  copyFile,
+  createCommand,
+  createGeneratorContext,
+  createInitialCommit,
+  createSpinner,
+  endpointToMCPTool,
+  ensureDir,
+  exists,
+  generateFromOpenAPI,
+  generateFromPrompt,
+  generateFromWizard,
+  getGitUser,
+  getTemplateDir,
+  initCommand,
+  initGitRepository,
+  isDirectory,
+  isGitInstalled,
+  isInsideGitRepository,
+  logger,
+  parseAndValidate,
+  parseOpenAPISpec,
+  parsePostmanCollection,
+  parseSwaggerSpec,
+  projectNameRegex,
+  promptAddResources,
+  promptAddTools,
+  promptIncludeExampleTool,
+  promptLanguage,
+  promptMultipleResources,
+  promptMultipleTools,
+  promptProjectDescription,
+  promptProjectName,
+  promptResourceConfig,
+  promptToolConfig,
+  promptTransport,
+  readDir,
+  readFile,
+  remove,
+  renderTemplate,
+  renderTemplateToFile,
+  resolveOutputPath,
+  runQuickWizard,
+  runWizard,
+  safeParseAndValidate,
+  selectEndpoints,
+  validateFilePath,
+  validateProjectName,
+  validateToolName,
+  validateUrl,
+  walkDir,
+  withSpinner,
+  writeFile
+};

package/package.json

@@ -0,0 +1,73 @@
+{
+    "name": "mcp-new",
+    "version": "0.1.0",
+    "description": "CLI generator for MCP servers. Like create-react-app, but for MCP.",
+    "type": "module",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "bin": {
+        "mcp-new": "./bin/mcp-new.js"
+    },
+    "files": [
+        "dist",
+        "bin",
+        "templates"
+    ],
+    "scripts": {
+        "dev": "tsup src/index.ts --watch --format esm",
+        "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
+        "test": "vitest",
+        "test:run": "vitest run",
+        "lint": "eslint src --ext .ts",
+        "lint:fix": "eslint src --ext .ts --fix",
+        "format": "prettier --write \"src/**/*.ts\"",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "cli",
+        "generator",
+        "anthropic",
+        "claude"
+    ],
+    "author": "Dinmukhanbet Aizharykov <dimashaijarikov@gmail.com>",
+    "license": "MIT",
+    "homepage": "https://github.com/d1maash/mcp-new#readme",
+    "bugs": {
+        "url": "https://github.com/d1maash/mcp-new/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/d1maash/mcp-new.git"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "dependencies": {
+        "@anthropic-ai/sdk": "^0.30.0",
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "chalk": "^5.3.0",
+        "commander": "^12.0.0",
+        "ejs": "^3.1.10",
+        "execa": "^8.0.0",
+        "fs-extra": "^11.2.0",
+        "inquirer": "^9.2.0",
+        "ora": "^8.0.0",
+        "yaml": "^2.4.0",
+        "zod": "^3.23.0"
+    },
+    "devDependencies": {
+        "@types/ejs": "^3.1.0",
+        "@types/fs-extra": "^11.0.0",
+        "@types/inquirer": "^9.0.0",
+        "@types/node": "^20.0.0",
+        "@typescript-eslint/eslint-plugin": "^7.0.0",
+        "@typescript-eslint/parser": "^7.0.0",
+        "eslint": "^8.57.0",
+        "prettier": "^3.2.0",
+        "tsup": "^8.0.0",
+        "typescript": "^5.4.0",
+        "vitest": "^1.6.0"
+    }
+}

package/templates/python/.env.example

@@ -0,0 +1,8 @@
+# Environment variables for your MCP server
+# Copy this file to .env and fill in your values
+
+# Example API key
+# API_KEY=your-api-key-here
+
+# Server configuration
+# PORT=3000

package/templates/python/.gitignore.ejs

@@ -0,0 +1,37 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+venv/
+.venv/
+env/
+.env/
+
+# Environment variables
+.env
+.env.local
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# pytest
+.pytest_cache/
+
+# mypy
+.mypy_cache/

package/templates/python/README.md.ejs

@@ -0,0 +1,78 @@
+# <%= name %>
+
+<%= description || 'MCP Server generated by create-mcp-server' %>
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or using requirements.txt:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Running the server
+
+```bash
+python -m src.server
+```
+
+Or if installed:
+
+```bash
+<%= name %>
+```
+
+## Configuration
+
+### Claude Desktop
+
+Add this to your Claude Desktop config file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "<%= name %>": {
+      "command": "python",
+      "args": ["-m", "src.server"],
+      "cwd": "<path-to-project>"
+    }
+  }
+}
+```
+
+## Available Tools
+
+<% if (includeExampleTool) { %>
+### example_tool
+
+A sample tool that demonstrates basic MCP tool functionality.
+
+**Parameters:**
+- `query` (string, required): The query parameter
+
+<% } %>
+<% tools.forEach(function(tool) { %>
+### <%= tool.name %>
+
+<%= tool.description %>
+
+<% if (tool.parameters && tool.parameters.length > 0) { %>
+**Parameters:**
+<% tool.parameters.forEach(function(param) { %>
+- `<%= param.name %>` (<%= param.type %><%= param.required ? ', required' : '' %>): <%= param.description %>
+<% }); %>
+<% } %>
+<% }); %>
+
+## License
+
+MIT

package/templates/python/pyproject.toml.ejs

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "<%= name %>"
+version = "1.0.0"
+description = "<%= description || 'MCP Server generated by create-mcp-server' %>"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.0.0",
+]
+
+[project.scripts]
+<%= name %> = "src.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

package/templates/python/requirements.txt.ejs

@@ -0,0 +1 @@
+mcp>=1.0.0

package/templates/python/src/__init__.py.ejs

@@ -0,0 +1,3 @@
+"""<%= name %> - MCP Server"""
+
+__version__ = "1.0.0"

package/templates/python/src/server.py.ejs

@@ -0,0 +1,98 @@
+"""
+<%= name %> MCP Server
+<%= description || 'Generated by create-mcp-server' %>
+"""
+
+import asyncio
+from mcp.server import Server
+<% if (transport === 'stdio') { %>
+from mcp.server.stdio import stdio_server
+<% } else { %>
+from mcp.server.sse import SseServerTransport
+<% } %>
+from mcp.types import Tool, TextContent
+
+# Create the server instance
+server = Server("<%= name %>")
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+    """List available tools."""
+    return [
+<% if (includeExampleTool) { %>
+        Tool(
+            name="example_tool",
+            description="An example tool that echoes the input",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The query to echo",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+<% } %>
+<% tools.forEach(function(tool) { %>
+        Tool(
+            name="<%= tool.name %>",
+            description="<%= tool.description %>",
+            inputSchema={
+                "type": "object",
+                "properties": {
+<% tool.parameters.forEach(function(param, index) { %>
+                    "<%= param.name %>": {
+                        "type": "<%= param.type %>",
+                        "description": "<%= param.description %>",
+                    }<%= index < tool.parameters.length - 1 ? ',' : '' %>
+<% }); %>
+                },
+                "required": [<%= tool.parameters.filter(p => p.required).map(p => '"' + p.name + '"').join(', ') %>],
+            },
+        ),
+<% }); %>
+    ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+    """Handle tool calls."""
+<% if (includeExampleTool) { %>
+    if name == "example_tool":
+        query = arguments.get("query", "")
+        return [TextContent(type="text", text=f"Echo: {query}")]
+<% } %>
+
+<% tools.forEach(function(tool) { %>
+    if name == "<%= tool.name %>":
+        # TODO: Implement <%= tool.name %> logic
+<% tool.parameters.forEach(function(param) { %>
+        <%= param.name %> = arguments.get("<%= param.name %>")
+<% }); %>
+        return [TextContent(type="text", text=f"<%= tool.name %> called with: {arguments}")]
+<% }); %>
+
+    raise ValueError(f"Unknown tool: {name}")
+
+
+async def main():
+    """Main entry point."""
+<% if (transport === 'stdio') { %>
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            server.create_initialization_options(),
+        )
+<% } else { %>
+    # SSE transport implementation
+    transport = SseServerTransport("/messages")
+    await server.run(transport)
+<% } %>
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/templates/python/src/tools/__init__.py.ejs

@@ -0,0 +1 @@
+"""Tools package for <%= name %>"""