mcp-creator-python 1.0.0__py3-none-any.whl

mcp_creator/tools/scaffold_server.py

@@ -0,0 +1,122 @@
+"""Scaffold a complete MCP server project."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mcp_creator.services import codegen, file_writer
+
+
+def scaffold_server(
+    package_name: str,
+    description: str,
+    tools: str,
+    output_dir: str = ".",
+    env_vars: str | None = None,
+    paid: bool = False,
+    paid_tools: str | None = None,
+    hosting: str = "local",
+) -> str:
+    """Scaffold a complete, runnable MCP server project.
+
+    Args:
+        package_name: PyPI package name (e.g. "my-weather-mcp").
+        description: One-line description of the server.
+        tools: JSON string — list of tool defs:
+               [{"name": "get_weather", "description": "...",
+                 "parameters": [{"name": "city", "type": "string",
+                                  "required": true, "description": "..."}],
+                 "returns": "Weather data as JSON"}]
+        output_dir: Parent directory where the project folder is created.
+        env_vars: Optional JSON string — list of env var defs:
+                  [{"name": "API_KEY", "description": "...", "required": true}]
+        paid: If true, add license key gating via mcp-marketplace-license SDK.
+        paid_tools: Optional JSON string — list of tool names to gate behind license.
+                    If omitted and paid=true, all tools are gated.
+        hosting: "local" (default, stdio) or "remote" (SSE/HTTP for hosted model).
+
+    Returns:
+        JSON string with created files and next steps.
+    """
+    tool_defs = json.loads(tools)
+    env_var_defs = json.loads(env_vars) if env_vars else None
+    paid_tool_list = json.loads(paid_tools) if paid_tools else None
+    module_name = codegen._to_module_name(package_name)
+
+    # Build file dict: relative_path -> content
+    files: dict[str, str] = {}
+
+    # Root files
+    files["pyproject.toml"] = codegen.render_pyproject(package_name, description, paid=paid)
+    files[".gitignore"] = codegen.render_gitignore()
+    files["README.md"] = codegen.render_readme(
+        package_name, description, tool_defs, paid=paid, hosting=hosting,
+    )
+
+    env_content = codegen.render_env_example(env_var_defs, paid=paid, hosting=hosting)
+    if env_content:
+        files[".env.example"] = env_content
+
+    if hosting == "remote":
+        files["Dockerfile"] = codegen.render_dockerfile(package_name)
+
+    # Source package
+    src = f"src/{module_name}"
+    files[f"{src}/__init__.py"] = codegen.render_init(package_name)
+    files[f"{src}/server.py"] = codegen.render_server(
+        package_name, tool_defs, paid=paid, paid_tools=paid_tool_list, hosting=hosting,
+    )
+    files[f"{src}/transport.py"] = codegen.render_transport(package_name)
+
+    # Tools and services
+    files[f"{src}/tools/__init__.py"] = ""
+    files[f"{src}/services/__init__.py"] = ""
+
+    for tool in tool_defs:
+        tool_name = tool["name"]
+        files[f"{src}/tools/{tool_name}.py"] = codegen.render_tool_module(
+            package_name, tool
+        )
+        files[f"{src}/services/{tool_name}_service.py"] = codegen.render_service_module(
+            tool
+        )
+
+    # Tests
+    files["tests/test_server.py"] = codegen.render_test_server(package_name, tool_defs)
+    for tool in tool_defs:
+        files[f"tests/test_{tool['name']}.py"] = codegen.render_test_tool(
+            package_name, tool
+        )
+
+    # Write to disk
+    project_dir = Path(output_dir).resolve() / package_name
+    written = file_writer.write_project_files(project_dir, files)
+
+    result = {
+        "success": True,
+        "project_dir": str(project_dir),
+        "files_created": len(written),
+        "file_list": sorted(files.keys()),
+        "module_name": module_name,
+        "paid": paid,
+        "hosting": hosting,
+        "next_steps": [
+            f"Project scaffolded at {project_dir}",
+            f"cd {project_dir} && uv venv .venv && source .venv/bin/activate && uv pip install -e '.[dev]'",
+            "Open the services/ folder and replace the TODO stubs with your real logic.",
+            "Run 'pytest -v' to verify everything works.",
+            "When ready, use build_package to build and publish_package to publish to PyPI.",
+        ],
+    }
+
+    if paid:
+        result["next_steps"].append(
+            "License gating is enabled. Users need MCP_LICENSE_KEY to use paid tools."
+        )
+    if hosting == "remote":
+        result["next_steps"].append(
+            "Remote hosting enabled. Use 'docker build' and 'docker run' to deploy."
+        )
+
+    return json.dumps(result, indent=2)

mcp_creator/tools/setup_github.py

@@ -0,0 +1,137 @@
+"""Initialize git and create a GitHub repo for the MCP server project."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from mcp_creator.services.subprocess_runner import run_command
+
+
+def setup_github(
+    project_dir: str,
+    repo_name: str,
+    description: str = "",
+    private: bool = False,
+) -> str:
+    """Initialize a git repo, create a GitHub repo, and push the project.
+
+    Requires the `gh` CLI to be installed and authenticated.
+
+    Args:
+        project_dir: Absolute path to the project root.
+        repo_name: GitHub repo name (e.g. "my-weather-mcp").
+        description: One-line repo description.
+        private: If True, create a private repo. Default is public.
+
+    Returns:
+        JSON string with repo URL and next steps.
+    """
+    project = Path(project_dir).resolve()
+
+    if not project.exists():
+        return json.dumps({
+            "success": False,
+            "error": f"Project directory not found: {project}",
+        })
+
+    # 1. Check gh CLI is available
+    gh_check = run_command(["gh", "auth", "status"], cwd=project)
+    if not gh_check["success"]:
+        return json.dumps({
+            "success": False,
+            "error": "GitHub CLI (gh) is not installed or not authenticated.",
+            "next_steps": [
+                "Install gh: https://cli.github.com/",
+                "Then run: gh auth login",
+            ],
+        })
+
+    # 2. git init (if not already a repo)
+    git_check = run_command(["git", "rev-parse", "--git-dir"], cwd=project)
+    if not git_check["success"]:
+        init_result = run_command(["git", "init"], cwd=project)
+        if not init_result["success"]:
+            return json.dumps({
+                "success": False,
+                "error": f"git init failed: {init_result['stderr']}",
+            })
+
+    # 3. Stage and commit all files
+    run_command(["git", "add", "."], cwd=project)
+    commit_result = run_command(
+        ["git", "commit", "-m", "Initial commit — scaffolded with mcp-creator"],
+        cwd=project,
+    )
+    # commit may fail if already committed — that's ok
+
+    # 4. Create GitHub repo
+    visibility = "--private" if private else "--public"
+    create_args = [
+        "gh", "repo", "create", repo_name,
+        visibility,
+        "--source", str(project),
+        "--push",
+    ]
+    if description:
+        create_args.extend(["--description", description])
+
+    create_result = run_command(create_args, cwd=project, timeout=30)
+
+    if not create_result["success"]:
+        # Maybe repo already exists — try to just add remote and push
+        if "already exists" in create_result["stderr"].lower():
+            # Get the GitHub username
+            whoami = run_command(["gh", "api", "user", "--jq", ".login"], cwd=project)
+            username = whoami["stdout"].strip() if whoami["success"] else "OWNER"
+            repo_url = f"https://github.com/{username}/{repo_name}"
+
+            run_command(
+                ["git", "remote", "add", "origin", f"{repo_url}.git"],
+                cwd=project,
+            )
+            push_result = run_command(
+                ["git", "push", "-u", "origin", "main"],
+                cwd=project,
+                timeout=30,
+            )
+            if not push_result["success"]:
+                # Try HEAD branch name
+                run_command(
+                    ["git", "push", "-u", "origin", "HEAD"],
+                    cwd=project,
+                    timeout=30,
+                )
+
+            return json.dumps({
+                "success": True,
+                "repo_url": repo_url,
+                "note": "Repo already existed — pushed to it.",
+                "next_steps": [
+                    f"Code pushed to {repo_url}",
+                    "Use generate_launchguide with this URL as the docs_url.",
+                ],
+            })
+
+        return json.dumps({
+            "success": False,
+            "error": f"Failed to create GitHub repo: {create_result['stderr']}",
+            "next_steps": [
+                "Check that gh is authenticated: gh auth status",
+                "Try creating the repo manually: gh repo create",
+            ],
+        })
+
+    # 5. Get the repo URL
+    whoami = run_command(["gh", "api", "user", "--jq", ".login"], cwd=project)
+    username = whoami["stdout"].strip() if whoami["success"] else "OWNER"
+    repo_url = f"https://github.com/{username}/{repo_name}"
+
+    return json.dumps({
+        "success": True,
+        "repo_url": repo_url,
+        "next_steps": [
+            f"GitHub repo created: {repo_url}",
+            "Use generate_launchguide with this URL as the docs_url for marketplace submission.",
+        ],
+    })

mcp_creator/transport.py

@@ -0,0 +1,11 @@
+"""Transport helpers for mcp-creator."""
+
+
+def run_stdio(mcp_app):
+    """Run the MCP server over stdio (default for Claude Code / Cursor)."""
+    mcp_app.run(transport="stdio")
+
+
+def run_http(mcp_app, host: str = "0.0.0.0", port: int = 8000):
+    """Run the MCP server over HTTP (for remote hosting)."""
+    mcp_app.run(transport="sse", host=host, port=port)

mcp_creator_python-1.0.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: mcp-creator-python
+Version: 1.0.0
+Summary: Create, build, and publish Python MCP servers to PyPI — conversationally
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: mcp[cli]>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mcp-creator
+
+Create, build, and publish Python MCP servers to PyPI — conversationally.
+
+Install `mcp-creator`, add it to your AI assistant, and it walks you through the entire process: naming your package, scaffolding a complete project, building, and publishing to PyPI.
+
+## Install
+
+```bash
+pip install mcp-creator
+```
+
+## Setup
+
+Add to Claude Code (`~/.claude/settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "mcp-creator": {
+      "command": "mcp-creator",
+      "args": []
+    }
+  }
+}
+```
+
+Or for Cursor (`.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "mcp-creator": {
+      "command": "mcp-creator",
+      "args": []
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|------|-------------|
+| `get_creator_profile` | Load your persistent profile — setup status, project history. Called first every session. |
+| `update_creator_profile` | Save setup state, usernames, and project history across sessions |
+| `check_setup` | Detect what's installed (uv, git, gh, PyPI token) — only walks through missing steps |
+| `check_pypi_name` | Check if a package name is available on PyPI |
+| `scaffold_server` | Create a complete MCP server project from a name + description + tool definitions |
+| `add_tool` | Add a new tool to an existing scaffolded project |
+| `build_package` | Run `uv build` on the project |
+| `publish_package` | Run `uv publish` to PyPI |
+| `setup_github` | Initialize git, create a GitHub repo, and push the code |
+| `generate_launchguide` | Create LAUNCHGUIDE.md for marketplace submission |
+
+## How It Works
+
+1. **Tell your AI what you want to build**: "I want an MCP server that checks the weather"
+2. **It checks the name**: calls `check_pypi_name` to verify availability on PyPI
+3. **It scaffolds the project**: calls `scaffold_server` with your tool definitions — generates a complete, runnable project
+4. **You fill in the logic**: replace the TODO stubs in `services/` with your real API calls
+5. **Build & publish**: `build_package` → `publish_package` → live on PyPI
+6. **Push to GitHub**: `setup_github` creates a repo and pushes your code
+7. **Submit to marketplace**: `generate_launchguide` creates the submission file with your repo URL
+
+## What Gets Generated
+
+For a project named `my-weather-mcp` with a `get_weather` tool:
+
+```
+my-weather-mcp/
+├── pyproject.toml         ← hatchling build, mcp[cli] dep, CLI entry point
+├── README.md              ← install instructions + MCP config JSON
+├── .gitignore
+├── src/my_weather_mcp/
+│   ├── __init__.py
+│   ├── server.py          ← FastMCP + @mcp.tool() for each tool
+│   ├── transport.py
+│   ├── tools/
+│   │   ├── __init__.py
+│   │   └── get_weather.py
+│   └── services/
+│       ├── __init__.py
+│       └── get_weather_service.py  ← TODO: your logic here
+└── tests/
+    ├── test_server.py
+    └── test_get_weather.py
+```
+
+The generated server runs immediately — stub services return placeholder data so you can test before implementing real logic.
+
+## Requirements
+
+- Python 3.11+
+- [uv](https://docs.astral.sh/uv/) (for building and publishing)
+
+## Development
+
+```bash
+git clone https://github.com/gmoneyn/mcp-creator.git
+cd mcp-creator
+uv venv .venv && source .venv/bin/activate
+uv pip install -e ".[dev]"
+pytest -v
+```

mcp_creator_python-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+mcp_creator/__init__.py,sha256=CDnhWvgG3-f_b63ojeUkXnc0M65xloLEqFiAAYFM7WE,77
+mcp_creator/server.py,sha256=-QFwJ9P8tIU4kuJYytB2GMhjqvmphP-KykjC2WYwE4c,6633
+mcp_creator/transport.py,sha256=Rt6TCg9f9RLuE3qc_r-rbBw3emeGOl5xtc4pky1hQw4,360
+mcp_creator/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_creator/services/codegen.py,sha256=m0ia1gjyYAqy6336RXztlJXFLEvwrZdV17rXk6-KoOo,18005
+mcp_creator/services/file_writer.py,sha256=sfSGgxOy7BqnmBUV7HPpcBpvRHa2uxGtN6CWubm0Xyc,1129
+mcp_creator/services/pypi_client.py,sha256=PhLplSDZIqdL1zjas2tNF4JIjL2jQsIk0nfytsZmpnY,1828
+mcp_creator/services/subprocess_runner.py,sha256=8KLmiipvDvEFu8oZZqthXFMFaY2A8BG-tP-sa1Uwan0,1447
+mcp_creator/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_creator/tools/add_tool.py,sha256=Sm2c8Wk93fCu9rFDNnPhLHWg0P1BxSNnjssz0hnVWhI,3139
+mcp_creator/tools/build_package.py,sha256=OKXUiRM5-Ja7J8OEi5wMDmK1Z83zDH3VuhDlrvfbTI8,1531
+mcp_creator/tools/check_pypi_name.py,sha256=0KfMaESyyXdXKtcE-DOm0_a6fiyhmSBONEM0hfXTJn4,1155
+mcp_creator/tools/check_setup.py,sha256=HFBR454bDwTBN0Buan_-_ottQSUYFgjBpWAotvEPz4s,3439
+mcp_creator/tools/creator_profile.py,sha256=LimuPZAzqCmDIgzvYt-Vc06BEwxiFyctVEM0BlNIvF4,3692
+mcp_creator/tools/generate_launchguide.py,sha256=B8m3js0eNgMt4IhQ2tIuxjkN6PokTKMNITDTmJcDUTE,2391
+mcp_creator/tools/publish_package.py,sha256=HBu96cz3D1gswqHczNytZnAX1pAXwyi5Tqv9O4fbmdk,2629
+mcp_creator/tools/scaffold_server.py,sha256=wNrJPriHwkSlxLR9AhstCd05zs5Bs3fK7X-hFI8YNyc,4557
+mcp_creator/tools/setup_github.py,sha256=nEWhJ8980JuncX80H7jemJ40dJwACVoO5kIuRYWWMe0,4697
+mcp_creator_python-1.0.0.dist-info/METADATA,sha256=M3ylLvuMcjck2RqhKBW7j6bJZFcmNvFYhbOIFhDsJZg,3730
+mcp_creator_python-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+mcp_creator_python-1.0.0.dist-info/entry_points.txt,sha256=yeXobTrjeJR7EAMxUxV-F7Jps88ER2qwd2M_d8SRlHo,63
+mcp_creator_python-1.0.0.dist-info/RECORD,,

mcp_creator_python-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_creator_python-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-creator-python = mcp_creator.server:main