mycode-aiagent 0.3.1__tar.gz → 0.4.1__tar.gz

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.3.1
+Version: 0.4.1
 Summary: Style-aware code generation — analyze any codebase and generate new code that matches its style
 License: MIT
 Project-URL: Homepage, https://github.com/RyanAbbottData/MyCode
@@ -93,7 +93,9 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 | Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
 | Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
 | OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
-| Custom MCP server | `--backend mcp` | Any MCP server at `--mcp-url` |
+| MyCode server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
+
+When `--backend mcp` is used with `analyze` or `generate`, the CLI delegates the entire operation to the running MyCode server — it calls the server's `analyze_codebase` or `generate_code` tool directly instead of running the pipeline locally. This is the recommended way to use MyCode in a multi-project or agentic setup.
 
 ### Setting up a local LLM
 
@@ -203,6 +205,11 @@ The profile is saved to `style_profile.json` by default. Specify a different pat
 my-code analyze ./path/to/codebase --profile ./profiles/my_team.json
 ```
 
+Delegating to a running MyCode server:
+```bash
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./path/to/codebase
+```
+
 ### Step 2 — Generate code
 
 ```bash
@@ -220,6 +227,9 @@ my-code --backend claude generate "write a binary search function"
 
 # Override the model
 my-code --backend claude --model claude-sonnet-4-6 generate "write a rate limiter"
+
+# Delegate to a running MyCode server
+my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a rate limiter"
 ```
 
 ---
@@ -243,9 +253,14 @@ Commands:
 
   generate TASK   Generate code matching the saved style profile
 
-  serve           Start an MCP server (blocks until Ctrl-C)
-    --host TEXT   Host to bind (default: 127.0.0.1)
-    --port INT    Port to listen on (default: 8080)
+  serve              Start an MCP server (blocks until Ctrl-C)
+    --host TEXT      Host to bind (default: 127.0.0.1)
+    --port INT       Port to listen on (default: 8080)
+    --daemon         Run as a detached background process
+    --pid-file TEXT  PID file path for daemon mode (default: mycode.pid)
+
+  stop               Stop a running daemon server
+    --pid-file TEXT  PID file written by 'serve --daemon' (default: mycode.pid)
 ```
 
 ---
@@ -313,7 +328,7 @@ MyCode can expose itself as an MCP server so any MCP-compatible agent or orchest
 ### Quick start
 
 ```bash
-# Local LLM backend (default)
+# Local LLM backend (default) — foreground, blocks until Ctrl-C
 my-code serve
 
 # Claude backend
@@ -333,6 +348,50 @@ MyCode MCP server running at http://127.0.0.1:8080/mcp
 Add to your MCP config:  {"mycode": {"url": "http://127.0.0.1:8080/mcp"}}
 ```
 
+### Running as a daemon
+
+Add `--daemon` to run the server as a detached background process. The terminal returns immediately and the server keeps running.
+
+```bash
+my-code --backend claude serve --daemon
+# → MyCode MCP server started as daemon (PID 12345) at http://127.0.0.1:8080/mcp
+# → Stop with: my-code stop
+```
+
+The PID is written to `mycode.pid` by default. Stop the server with:
+
+```bash
+my-code stop
+```
+
+When running multiple instances on different ports, use `--pid-file` to keep them separate:
+
+```bash
+my-code --backend claude serve --port 8080 --daemon --pid-file mycode-8080.pid
+my-code --backend openai serve --port 8081 --daemon --pid-file mycode-8081.pid
+
+my-code stop --pid-file mycode-8080.pid
+my-code stop --pid-file mycode-8081.pid
+```
+
+### Using the server from the CLI
+
+Start a MyCode server as a daemon, then point `analyze` and `generate` at it with `--backend mcp`. The CLI calls the server's tools directly — the server handles all analysis and generation using whichever LLM it was started with.
+
+```bash
+# Start the server (uses a local LLM at port 8001 as its brain)
+my-code --backend mcp --mcp-url http://localhost:8001/mcp serve --daemon --port 8000
+
+# Analyze a codebase via the server
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./my_project
+
+# Generate code via the server (loads style_profile.json locally and sends it)
+my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a retry decorator"
+
+# Stop the server
+my-code stop
+```
+
 ### Connecting from an MCP consumer
 
 Add the printed snippet to your consumer's MCP config file (e.g. `.mcp.json`):
@@ -412,7 +471,7 @@ Both test suites use a `MockBackend` — no live AI backend required.
 my_code/
 ├── analyzer.py          # StyleAnalyzer — scans files, builds style profile
 ├── generator.py         # generate_code() — formats prompt and calls backend
-├── mcp_client.py        # Generic MCP client (Streamable HTTP transport)
+├── mcp_client.py        # MCPClient (raw LLM wrapper) + MyCodeClient (server delegation)
 ├── server.py            # MCPServer — exposes analyze/generate as MCP tools
 ├── cli.py               # CLI entry point (my-code command)
 ├── backends/

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/README.md

@@ -64,7 +64,9 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 | Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
 | Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
 | OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
-| Custom MCP server | `--backend mcp` | Any MCP server at `--mcp-url` |
+| MyCode server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
+
+When `--backend mcp` is used with `analyze` or `generate`, the CLI delegates the entire operation to the running MyCode server — it calls the server's `analyze_codebase` or `generate_code` tool directly instead of running the pipeline locally. This is the recommended way to use MyCode in a multi-project or agentic setup.
 
 ### Setting up a local LLM
 
@@ -174,6 +176,11 @@ The profile is saved to `style_profile.json` by default. Specify a different pat
 my-code analyze ./path/to/codebase --profile ./profiles/my_team.json
 ```
 
+Delegating to a running MyCode server:
+```bash
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./path/to/codebase
+```
+
 ### Step 2 — Generate code
 
 ```bash
@@ -191,6 +198,9 @@ my-code --backend claude generate "write a binary search function"
 
 # Override the model
 my-code --backend claude --model claude-sonnet-4-6 generate "write a rate limiter"
+
+# Delegate to a running MyCode server
+my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a rate limiter"
 ```
 
 ---
@@ -214,9 +224,14 @@ Commands:
 
   generate TASK   Generate code matching the saved style profile
 
-  serve           Start an MCP server (blocks until Ctrl-C)
-    --host TEXT   Host to bind (default: 127.0.0.1)
-    --port INT    Port to listen on (default: 8080)
+  serve              Start an MCP server (blocks until Ctrl-C)
+    --host TEXT      Host to bind (default: 127.0.0.1)
+    --port INT       Port to listen on (default: 8080)
+    --daemon         Run as a detached background process
+    --pid-file TEXT  PID file path for daemon mode (default: mycode.pid)
+
+  stop               Stop a running daemon server
+    --pid-file TEXT  PID file written by 'serve --daemon' (default: mycode.pid)
 ```
 
 ---
@@ -284,7 +299,7 @@ MyCode can expose itself as an MCP server so any MCP-compatible agent or orchest
 ### Quick start
 
 ```bash
-# Local LLM backend (default)
+# Local LLM backend (default) — foreground, blocks until Ctrl-C
 my-code serve
 
 # Claude backend
@@ -304,6 +319,50 @@ MyCode MCP server running at http://127.0.0.1:8080/mcp
 Add to your MCP config:  {"mycode": {"url": "http://127.0.0.1:8080/mcp"}}
 ```
 
+### Running as a daemon
+
+Add `--daemon` to run the server as a detached background process. The terminal returns immediately and the server keeps running.
+
+```bash
+my-code --backend claude serve --daemon
+# → MyCode MCP server started as daemon (PID 12345) at http://127.0.0.1:8080/mcp
+# → Stop with: my-code stop
+```
+
+The PID is written to `mycode.pid` by default. Stop the server with:
+
+```bash
+my-code stop
+```
+
+When running multiple instances on different ports, use `--pid-file` to keep them separate:
+
+```bash
+my-code --backend claude serve --port 8080 --daemon --pid-file mycode-8080.pid
+my-code --backend openai serve --port 8081 --daemon --pid-file mycode-8081.pid
+
+my-code stop --pid-file mycode-8080.pid
+my-code stop --pid-file mycode-8081.pid
+```
+
+### Using the server from the CLI
+
+Start a MyCode server as a daemon, then point `analyze` and `generate` at it with `--backend mcp`. The CLI calls the server's tools directly — the server handles all analysis and generation using whichever LLM it was started with.
+
+```bash
+# Start the server (uses a local LLM at port 8001 as its brain)
+my-code --backend mcp --mcp-url http://localhost:8001/mcp serve --daemon --port 8000
+
+# Analyze a codebase via the server
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./my_project
+
+# Generate code via the server (loads style_profile.json locally and sends it)
+my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a retry decorator"
+
+# Stop the server
+my-code stop
+```
+
 ### Connecting from an MCP consumer
 
 Add the printed snippet to your consumer's MCP config file (e.g. `.mcp.json`):
@@ -383,7 +442,7 @@ Both test suites use a `MockBackend` — no live AI backend required.
 my_code/
 ├── analyzer.py          # StyleAnalyzer — scans files, builds style profile
 ├── generator.py         # generate_code() — formats prompt and calls backend
-├── mcp_client.py        # Generic MCP client (Streamable HTTP transport)
+├── mcp_client.py        # MCPClient (raw LLM wrapper) + MyCodeClient (server delegation)
 ├── server.py            # MCPServer — exposes analyze/generate as MCP tools
 ├── cli.py               # CLI entry point (my-code command)
 ├── backends/

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/my_code/cli.py

@@ -8,12 +8,16 @@ Usage:
 
 import argparse
 import json
+import os
+import signal
+import subprocess
 import sys
 from pathlib import Path
 
 from .analyzer import StyleAnalyzer
 from .backends import make_backend
 from .generator import generate_code
+from .mcp_client import MyCodeClient
 from .server import MCPServer
 
 DEFAULT_PROFILE = Path("style_profile.json")
@@ -24,6 +28,13 @@ def cmd_analyze(args):
     if not root.exists():
         sys.exit(f"Error: directory not found: {root}")
 
+    if args.backend == "mcp":
+        client = MyCodeClient(args.mcp_url, args.timeout)
+        print(f"Analyzing codebase at {root} via MyCode server ...")
+        profile = client.analyze_codebase(str(root))
+        StyleAnalyzer.save_profile(profile, Path(args.profile))
+        return
+
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
@@ -49,6 +60,13 @@ def cmd_generate(args):
             "Run 'analyze' first."
         )
 
+    if args.backend == "mcp":
+        profile = json.loads(profile_path.read_text(encoding="utf-8"))
+        client = MyCodeClient(args.mcp_url, args.timeout)
+        print("Generating code ...\n")
+        print(client.generate_code(args.task, profile=profile))
+        return
+
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
@@ -65,7 +83,47 @@ def cmd_generate(args):
     print(code)
 
 
+def _spawn_daemon(args):
+    cmd = [
+        sys.executable, "-m", "my_code",
+        "--backend", args.backend,
+        "--ricky-url", args.ricky_url,
+        "--mcp-url", args.mcp_url,
+        "--timeout", str(args.timeout),
+        "--profile", args.profile,
+        "serve",
+        "--host", args.host,
+        "--port", str(args.port),
+    ]
+    if args.api_key:
+        cmd += ["--api-key", args.api_key]
+    if args.model:
+        cmd += ["--model", args.model]
+
+    kwargs = {"stdout": subprocess.DEVNULL, "stderr": subprocess.DEVNULL}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        kwargs["start_new_session"] = True
+
+    proc = subprocess.Popen(cmd, **kwargs)
+    Path(args.pid_file).write_text(str(proc.pid))
+    print(f"MyCode MCP server started as daemon (PID {proc.pid}) at http://{args.host}:{args.port}/mcp")
+    print(f"Stop with: my-code stop --pid-file {args.pid_file}")
+
+
+def cmd_stop(args):
+    pid_file = Path(args.pid_file)
+    pid = int(pid_file.read_text().strip())
+    os.kill(pid, signal.SIGTERM)
+    pid_file.unlink()
+    print(f"MyCode MCP server (PID {pid}) stopped.")
+
+
 def cmd_serve(args):
+    if args.daemon:
+        _spawn_daemon(args)
+        return
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
@@ -104,8 +162,14 @@ def main():
     p_serve = sub.add_parser("serve", help="Start an MCP server exposing analyze and generate as tools")
     p_serve.add_argument("--host", default="127.0.0.1", help="Host to bind (default: 127.0.0.1)")
     p_serve.add_argument("--port", type=int, default=8080, help="Port to listen on (default: 8080)")
+    p_serve.add_argument("--daemon", action="store_true", help="Run server as a detached background process")
+    p_serve.add_argument("--pid-file", default="mycode.pid", help="PID file path when running as daemon (default: mycode.pid)")
     p_serve.set_defaults(func=cmd_serve)
 
+    p_stop = sub.add_parser("stop", help="Stop a running daemon server")
+    p_stop.add_argument("--pid-file", default="mycode.pid", help="PID file written by 'serve --daemon' (default: mycode.pid)")
+    p_stop.set_defaults(func=cmd_stop)
+
     args = parser.parse_args()
     args.func(args)
 

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/my_code/mcp_client.py

@@ -137,3 +137,29 @@ class MCPClient:
             "arguments": {self._analyze_arg: prompt},
         })
         return self._extract_text(result)
+
+
+class MyCodeClient(MCPClient):
+    """Client for a running MyCode MCP server. Calls semantic tools directly."""
+
+    def __init__(self, url: str = "http://localhost:8000/mcp", timeout: int = 120):
+        self.url = url
+        self._timeout = timeout
+        self._session_id = None
+        self._initialize()
+
+    def analyze_codebase(self, path: str, save_to: str | None = None) -> dict:
+        args = {"path": path}
+        if save_to:
+            args["save_to"] = save_to
+        result = self._post("tools/call", {"name": "analyze_codebase", "arguments": args})
+        return json.loads(self._extract_text(result))
+
+    def generate_code(self, task: str, profile: dict | None = None, profile_path: str | None = None) -> str:
+        args = {"task": task}
+        if profile is not None:
+            args["profile"] = profile
+        elif profile_path:
+            args["profile_path"] = profile_path
+        result = self._post("tools/call", {"name": "generate_code", "arguments": args})
+        return self._extract_text(result)

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/mycode_aiagent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.3.1
+Version: 0.4.1
 Summary: Style-aware code generation — analyze any codebase and generate new code that matches its style
 License: MIT
 Project-URL: Homepage, https://github.com/RyanAbbottData/MyCode
@@ -93,7 +93,9 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 | Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
 | Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
 | OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
-| Custom MCP server | `--backend mcp` | Any MCP server at `--mcp-url` |
+| MyCode server | `--backend mcp` | A running MyCode MCP server at `--mcp-url` |
+
+When `--backend mcp` is used with `analyze` or `generate`, the CLI delegates the entire operation to the running MyCode server — it calls the server's `analyze_codebase` or `generate_code` tool directly instead of running the pipeline locally. This is the recommended way to use MyCode in a multi-project or agentic setup.
 
 ### Setting up a local LLM
 
@@ -203,6 +205,11 @@ The profile is saved to `style_profile.json` by default. Specify a different pat
 my-code analyze ./path/to/codebase --profile ./profiles/my_team.json
 ```
 
+Delegating to a running MyCode server:
+```bash
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./path/to/codebase
+```
+
 ### Step 2 — Generate code
 
 ```bash
@@ -220,6 +227,9 @@ my-code --backend claude generate "write a binary search function"
 
 # Override the model
 my-code --backend claude --model claude-sonnet-4-6 generate "write a rate limiter"
+
+# Delegate to a running MyCode server
+my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a rate limiter"
 ```
 
 ---
@@ -243,9 +253,14 @@ Commands:
 
   generate TASK   Generate code matching the saved style profile
 
-  serve           Start an MCP server (blocks until Ctrl-C)
-    --host TEXT   Host to bind (default: 127.0.0.1)
-    --port INT    Port to listen on (default: 8080)
+  serve              Start an MCP server (blocks until Ctrl-C)
+    --host TEXT      Host to bind (default: 127.0.0.1)
+    --port INT       Port to listen on (default: 8080)
+    --daemon         Run as a detached background process
+    --pid-file TEXT  PID file path for daemon mode (default: mycode.pid)
+
+  stop               Stop a running daemon server
+    --pid-file TEXT  PID file written by 'serve --daemon' (default: mycode.pid)
 ```
 
 ---
@@ -313,7 +328,7 @@ MyCode can expose itself as an MCP server so any MCP-compatible agent or orchest
 ### Quick start
 
 ```bash
-# Local LLM backend (default)
+# Local LLM backend (default) — foreground, blocks until Ctrl-C
 my-code serve
 
 # Claude backend
@@ -333,6 +348,50 @@ MyCode MCP server running at http://127.0.0.1:8080/mcp
 Add to your MCP config:  {"mycode": {"url": "http://127.0.0.1:8080/mcp"}}
 ```
 
+### Running as a daemon
+
+Add `--daemon` to run the server as a detached background process. The terminal returns immediately and the server keeps running.
+
+```bash
+my-code --backend claude serve --daemon
+# → MyCode MCP server started as daemon (PID 12345) at http://127.0.0.1:8080/mcp
+# → Stop with: my-code stop
+```
+
+The PID is written to `mycode.pid` by default. Stop the server with:
+
+```bash
+my-code stop
+```
+
+When running multiple instances on different ports, use `--pid-file` to keep them separate:
+
+```bash
+my-code --backend claude serve --port 8080 --daemon --pid-file mycode-8080.pid
+my-code --backend openai serve --port 8081 --daemon --pid-file mycode-8081.pid
+
+my-code stop --pid-file mycode-8080.pid
+my-code stop --pid-file mycode-8081.pid
+```
+
+### Using the server from the CLI
+
+Start a MyCode server as a daemon, then point `analyze` and `generate` at it with `--backend mcp`. The CLI calls the server's tools directly — the server handles all analysis and generation using whichever LLM it was started with.
+
+```bash
+# Start the server (uses a local LLM at port 8001 as its brain)
+my-code --backend mcp --mcp-url http://localhost:8001/mcp serve --daemon --port 8000
+
+# Analyze a codebase via the server
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze ./my_project
+
+# Generate code via the server (loads style_profile.json locally and sends it)
+my-code --backend mcp --mcp-url http://localhost:8000/mcp generate "write a retry decorator"
+
+# Stop the server
+my-code stop
+```
+
 ### Connecting from an MCP consumer
 
 Add the printed snippet to your consumer's MCP config file (e.g. `.mcp.json`):
@@ -412,7 +471,7 @@ Both test suites use a `MockBackend` — no live AI backend required.
 my_code/
 ├── analyzer.py          # StyleAnalyzer — scans files, builds style profile
 ├── generator.py         # generate_code() — formats prompt and calls backend
-├── mcp_client.py        # Generic MCP client (Streamable HTTP transport)
+├── mcp_client.py        # MCPClient (raw LLM wrapper) + MyCodeClient (server delegation)
 ├── server.py            # MCPServer — exposes analyze/generate as MCP tools
 ├── cli.py               # CLI entry point (my-code command)
 ├── backends/

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/mycode_aiagent.egg-info/SOURCES.txt

@@ -21,4 +21,5 @@ mycode_aiagent.egg-info/dependency_links.txt
 mycode_aiagent.egg-info/entry_points.txt
 mycode_aiagent.egg-info/requires.txt
 mycode_aiagent.egg-info/top_level.txt
-tests/test_library.py
+tests/test_library.py
+tests/test_server.py

{mycode_aiagent-0.3.1 → mycode_aiagent-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mycode-aiagent"
-version = "0.3.1"
+version = "0.4.1"
 description = "Style-aware code generation — analyze any codebase and generate new code that matches its style"
 readme = "README.md"
 requires-python = ">=3.10"

mycode_aiagent-0.4.1/tests/test_server.py

@@ -0,0 +1,138 @@
+"""
+Tests for the MyCode MCP server.
+Spins up a real ThreadingHTTPServer against a MockBackend and exercises the protocol.
+No live AI backend required.
+"""
+import json
+import socket
+import threading
+import unittest
+from pathlib import Path
+
+import requests
+
+from my_code.server import MCPServer
+from my_code import AIBackend
+
+# ── Mock backend (same contract as the one in test_library.py) ────────────────
+
+MOCK_PROFILE = {
+    "naming": {"functions": "snake_case", "classes": "PascalCase"},
+    "comments": {"docstring_style": "plain"},
+    "representative_snippets": ["def foo(x: int) -> str:\n    return str(x)"],
+}
+
+class MockBackend(AIBackend):
+    max_file_chars = 6000
+
+    def ask_to_analyze(self, prompt: str) -> str:
+        return json.dumps(MOCK_PROFILE)
+
+    def ask_for_code(self, prompt: str) -> str:
+        return "def hello(name: str) -> str:\n    return f'Hello, {name}'"
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _post(url: str, method: str, params: dict, session_id: str | None = None) -> requests.Response:
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+    }
+    if session_id:
+        headers["Mcp-Session-Id"] = session_id
+    return requests.post(
+        url,
+        json={"jsonrpc": "2.0", "id": "1", "method": method, "params": params},
+        headers=headers,
+        timeout=10,
+    )
+
+
+def _parse(resp: requests.Response) -> dict:
+    for line in resp.text.splitlines():
+        if line.startswith("data:"):
+            return json.loads(line[5:].strip())
+    raise AssertionError(f"No SSE data line in response: {resp.text[:300]}")
+
+
+class TestMCPServer(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        port = _free_port()
+        cls.url = f"http://127.0.0.1:{port}/mcp"
+        server = MCPServer(MockBackend(), host="127.0.0.1", port=port)
+        cls.httpd = server.start()
+        t = threading.Thread(target=cls.httpd.serve_forever, daemon=True)
+        t.start()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.httpd.shutdown()
+
+    def test_initialize(self):
+        resp = _post(self.url, "initialize", {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {"name": "test", "version": "1"},
+        })
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn("Mcp-Session-Id", resp.headers)
+        msg = _parse(resp)
+        self.assertIn("result", msg)
+        self.assertEqual(msg["result"]["serverInfo"]["name"], "mycode")
+
+    def test_tools_list(self):
+        resp = _post(self.url, "tools/list", {})
+        self.assertEqual(resp.status_code, 200)
+        msg = _parse(resp)
+        tools = {t["name"] for t in msg["result"]["tools"]}
+        self.assertEqual(tools, {"analyze_codebase", "generate_code"})
+
+    def test_analyze_codebase(self):
+        path = str(Path(__file__).parent.parent / "my_code")
+        resp = _post(self.url, "tools/call", {
+            "name": "analyze_codebase",
+            "arguments": {"path": path},
+        })
+        self.assertEqual(resp.status_code, 200)
+        msg = _parse(resp)
+        text = msg["result"]["content"][0]["text"]
+        profile = json.loads(text)
+        self.assertIn("naming", profile)
+
+    def test_generate_code(self):
+        resp = _post(self.url, "tools/call", {
+            "name": "generate_code",
+            "arguments": {"task": "write a greeting function", "profile": MOCK_PROFILE},
+        })
+        self.assertEqual(resp.status_code, 200)
+        msg = _parse(resp)
+        code = msg["result"]["content"][0]["text"]
+        self.assertTrue(len(code) > 0)
+        self.assertIn("def", code)
+
+    def test_unknown_method(self):
+        resp = _post(self.url, "nonexistent/method", {})
+        self.assertEqual(resp.status_code, 200)
+        msg = _parse(resp)
+        self.assertIn("error", msg)
+        self.assertEqual(msg["error"]["code"], -32601)
+
+    def test_unknown_tool(self):
+        resp = _post(self.url, "tools/call", {
+            "name": "does_not_exist",
+            "arguments": {},
+        })
+        self.assertEqual(resp.status_code, 200)
+        msg = _parse(resp)
+        self.assertIn("error", msg)
+        self.assertEqual(msg["error"]["code"], -32602)
+
+
+if __name__ == "__main__":
+    unittest.main()