mycode-aiagent 0.4.0__tar.gz → 0.4.2__tar.gz

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.4.0
+Version: 0.4.2
 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
@@ -90,14 +90,15 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 
 | Backend | Flag | Requirement |
 |---|---|---|
-| Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
-| Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
+| Anthropic Claude | `--backend claude` (default) | `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` |
+| Any MCP server | `--backend mcp` | An MCP server at `--mcp-url` (MyCode server or local LLM wrapper) |
+
+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
 
-The `llama` backend expects an MCP server at `http://localhost:8000/mcp` that exposes two tools: one for code generation and one for analysis. Any MCP-compatible wrapper around a local model will work. Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
+The `mcp` backend can connect to any MCP server, including a local LLM wrapper. The server must expose two tools: one for code generation and one for analysis (tool name must contain `"analyze"`). Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
 
 **1. Download a model**
 
@@ -124,7 +125,7 @@ python -m llama_cpp.server \
 
 **3. Wrap it with an MCP server**
 
-The `llama` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
+The `mcp` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
 - A **code generation tool** (name must not contain `"analyze"`)
 - An **analysis tool** (name must contain `"analyze"`)
 
@@ -166,13 +167,13 @@ python llm_mcp_server.py
 **4. Point MyCode at it**
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:8000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze .
 ```
 
 Or set a custom URL if your server runs on a different port:
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:9000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:9000/mcp analyze .
 ```
 
 ---
@@ -203,6 +204,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 +226,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"
 ```
 
 ---
@@ -230,11 +239,10 @@ my-code --backend claude --model claude-sonnet-4-6 generate "write a rate limite
 my-code [OPTIONS] COMMAND
 
 Options:
-  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --backend {claude,openai,mcp}          AI backend to use (default: claude)
   --api-key TEXT                         API key for claude/openai backends
   --model TEXT                           Override the default model
-  --ricky-url TEXT                       Local LLM MCP server URL (default: http://localhost:8000/mcp)
-  --mcp-url TEXT                         Custom MCP server URL (default: http://localhost:8001/mcp)
+  --mcp-url TEXT                         MCP server URL (default: http://localhost:8001/mcp)
   --profile TEXT                         Path to style profile JSON (default: style_profile.json)
 
 Commands:
@@ -364,6 +372,24 @@ 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`):
@@ -443,12 +469,11 @@ 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/
 │   ├── base.py          # AIBackend abstract base class
-│   ├── ricky_backend.py # Local LLM backend (connects via MCP)
 │   ├── claude_backend.py
 │   ├── openai_backend.py
 │   └── mcp_backend.py   # Generic MCP server backend

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/README.md

@@ -61,14 +61,15 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 
 | Backend | Flag | Requirement |
 |---|---|---|
-| Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
-| Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
+| Anthropic Claude | `--backend claude` (default) | `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` |
+| Any MCP server | `--backend mcp` | An MCP server at `--mcp-url` (MyCode server or local LLM wrapper) |
+
+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
 
-The `llama` backend expects an MCP server at `http://localhost:8000/mcp` that exposes two tools: one for code generation and one for analysis. Any MCP-compatible wrapper around a local model will work. Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
+The `mcp` backend can connect to any MCP server, including a local LLM wrapper. The server must expose two tools: one for code generation and one for analysis (tool name must contain `"analyze"`). Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
 
 **1. Download a model**
 
@@ -95,7 +96,7 @@ python -m llama_cpp.server \
 
 **3. Wrap it with an MCP server**
 
-The `llama` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
+The `mcp` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
 - A **code generation tool** (name must not contain `"analyze"`)
 - An **analysis tool** (name must contain `"analyze"`)
 
@@ -137,13 +138,13 @@ python llm_mcp_server.py
 **4. Point MyCode at it**
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:8000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze .
 ```
 
 Or set a custom URL if your server runs on a different port:
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:9000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:9000/mcp analyze .
 ```
 
 ---
@@ -174,6 +175,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 +197,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"
 ```
 
 ---
@@ -201,11 +210,10 @@ my-code --backend claude --model claude-sonnet-4-6 generate "write a rate limite
 my-code [OPTIONS] COMMAND
 
 Options:
-  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --backend {claude,openai,mcp}          AI backend to use (default: claude)
   --api-key TEXT                         API key for claude/openai backends
   --model TEXT                           Override the default model
-  --ricky-url TEXT                       Local LLM MCP server URL (default: http://localhost:8000/mcp)
-  --mcp-url TEXT                         Custom MCP server URL (default: http://localhost:8001/mcp)
+  --mcp-url TEXT                         MCP server URL (default: http://localhost:8001/mcp)
   --profile TEXT                         Path to style profile JSON (default: style_profile.json)
 
 Commands:
@@ -335,6 +343,24 @@ 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`):
@@ -414,12 +440,11 @@ 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/
 │   ├── base.py          # AIBackend abstract base class
-│   ├── ricky_backend.py # Local LLM backend (connects via MCP)
 │   ├── claude_backend.py
 │   ├── openai_backend.py
 │   └── mcp_backend.py   # Generic MCP server backend

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/my_code/__init__.py

@@ -2,7 +2,7 @@ __version__ = "0.3.0"
 
 from .analyzer import StyleAnalyzer
 from .generator import generate_code
-from .backends import AIBackend, ClaudeBackend, OpenAIBackend, RickyBackend, MCPBackend, make_backend
+from .backends import AIBackend, ClaudeBackend, OpenAIBackend, MCPBackend, make_backend
 from .server import MCPServer
 
 
@@ -17,7 +17,6 @@ __all__ = [
     "AIBackend",
     "ClaudeBackend",
     "OpenAIBackend",
-    "RickyBackend",
     "MCPBackend",
     "make_backend",
     "MCPServer",

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/my_code/backends/__init__.py

@@ -3,16 +3,14 @@ import os
 from .base import AIBackend
 from .claude_backend import ClaudeBackend
 from .openai_backend import OpenAIBackend
-from .ricky_backend import RickyBackend
 from .mcp_backend import MCPBackend
 
-__all__ = ["AIBackend", "ClaudeBackend", "OpenAIBackend", "RickyBackend", "MCPBackend", "make_backend"]
+__all__ = ["AIBackend", "ClaudeBackend", "OpenAIBackend", "MCPBackend", "make_backend"]
 
 
 def make_backend(
-    backend: str = "llama",
+    backend: str = "claude",
     api_key: str | None = None,
-    ricky_url: str = "http://localhost:8000/mcp",
     mcp_url: str = "http://localhost:8001/mcp",
     model: str | None = None,
     timeout: int = 120,
@@ -29,6 +27,4 @@ def make_backend(
         return OpenAIBackend(api_key=key, **{"model": model} if model else {})
     if backend == "mcp":
         return MCPBackend(url=mcp_url, timeout=timeout)
-    if backend == "llama":
-        return RickyBackend(url=ricky_url, timeout=timeout)
-    raise ValueError(f"Unknown backend {backend!r}. Choose: llama, claude, openai, mcp")
+    raise ValueError(f"Unknown backend {backend!r}. Choose: claude, openai, mcp")

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/my_code/cli.py

@@ -2,8 +2,8 @@
 Style-aware code generation agent.
 
 Usage:
-  my-code [--backend llama|claude|openai] analyze <dir>
-  my-code [--backend llama|claude|openai] --api-key <key> generate "<task>"
+  my-code [--backend claude|openai|mcp] analyze <dir>
+  my-code [--backend claude|openai|mcp] --api-key <key> generate "<task>"
 """
 
 import argparse
@@ -17,6 +17,7 @@ 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")
@@ -27,10 +28,16 @@ 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,
-        ricky_url=args.ricky_url,
         mcp_url=args.mcp_url,
         model=args.model,
         timeout=args.timeout,
@@ -52,10 +59,16 @@ 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,
-        ricky_url=args.ricky_url,
         mcp_url=args.mcp_url,
         model=args.model,
         timeout=args.timeout,
@@ -72,7 +85,6 @@ 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,
@@ -112,7 +124,6 @@ def cmd_serve(args):
     backend = make_backend(
         backend=args.backend,
         api_key=args.api_key,
-        ricky_url=args.ricky_url,
         mcp_url=args.mcp_url,
         model=args.model,
         timeout=args.timeout,
@@ -123,12 +134,11 @@ def cmd_serve(args):
 def main():
     parser = argparse.ArgumentParser(description="Style-aware code agent")
     parser.add_argument(
-        "--backend", default="llama", choices=["llama", "claude", "openai", "mcp"],
-        help="AI backend to use (default: llama)",
+        "--backend", default="claude", choices=["claude", "openai", "mcp"],
+        help="AI backend to use (default: claude)",
     )
     parser.add_argument("--api-key", default=None, help="API key (claude/openai); falls back to env var")
     parser.add_argument("--model", default=None, help="Override default model for claude/openai backends")
-    parser.add_argument("--ricky-url", default="http://localhost:8000/mcp", help="Ricky MCP server URL (llama backend)")
     parser.add_argument("--mcp-url", default="http://localhost:8001/mcp", help="MCP server URL (mcp backend)")
     parser.add_argument("--timeout", type=int, default=120, help="Request timeout in seconds (default: 120)")
     parser.add_argument("--profile", default=str(DEFAULT_PROFILE))

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/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.4.0 → mycode_aiagent-0.4.2}/mycode_aiagent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.4.0
+Version: 0.4.2
 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
@@ -90,14 +90,15 @@ MyCode delegates inference to a pluggable backend. Choose one based on what you
 
 | Backend | Flag | Requirement |
 |---|---|---|
-| Local LLM | `--backend llama` (default) | MCP server running at `localhost:8000` |
-| Anthropic Claude | `--backend claude` | `ANTHROPIC_API_KEY` env var or `--api-key` |
+| Anthropic Claude | `--backend claude` (default) | `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` |
+| Any MCP server | `--backend mcp` | An MCP server at `--mcp-url` (MyCode server or local LLM wrapper) |
+
+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
 
-The `llama` backend expects an MCP server at `http://localhost:8000/mcp` that exposes two tools: one for code generation and one for analysis. Any MCP-compatible wrapper around a local model will work. Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
+The `mcp` backend can connect to any MCP server, including a local LLM wrapper. The server must expose two tools: one for code generation and one for analysis (tool name must contain `"analyze"`). Here is a recommended setup using [llama.cpp](https://github.com/ggerganov/llama.cpp):
 
 **1. Download a model**
 
@@ -124,7 +125,7 @@ python -m llama_cpp.server \
 
 **3. Wrap it with an MCP server**
 
-The `llama` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
+The `mcp` backend communicates over MCP, not directly with the llama.cpp HTTP API. You need a thin MCP wrapper that exposes two tools:
 - A **code generation tool** (name must not contain `"analyze"`)
 - An **analysis tool** (name must contain `"analyze"`)
 
@@ -166,13 +167,13 @@ python llm_mcp_server.py
 **4. Point MyCode at it**
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:8000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:8000/mcp analyze .
 ```
 
 Or set a custom URL if your server runs on a different port:
 
 ```bash
-my-code --backend llama --ricky-url http://localhost:9000/mcp analyze .
+my-code --backend mcp --mcp-url http://localhost:9000/mcp analyze .
 ```
 
 ---
@@ -203,6 +204,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 +226,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"
 ```
 
 ---
@@ -230,11 +239,10 @@ my-code --backend claude --model claude-sonnet-4-6 generate "write a rate limite
 my-code [OPTIONS] COMMAND
 
 Options:
-  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --backend {claude,openai,mcp}          AI backend to use (default: claude)
   --api-key TEXT                         API key for claude/openai backends
   --model TEXT                           Override the default model
-  --ricky-url TEXT                       Local LLM MCP server URL (default: http://localhost:8000/mcp)
-  --mcp-url TEXT                         Custom MCP server URL (default: http://localhost:8001/mcp)
+  --mcp-url TEXT                         MCP server URL (default: http://localhost:8001/mcp)
   --profile TEXT                         Path to style profile JSON (default: style_profile.json)
 
 Commands:
@@ -364,6 +372,24 @@ 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`):
@@ -443,12 +469,11 @@ 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/
 │   ├── base.py          # AIBackend abstract base class
-│   ├── ricky_backend.py # Local LLM backend (connects via MCP)
 │   ├── claude_backend.py
 │   ├── openai_backend.py
 │   └── mcp_backend.py   # Generic MCP server backend

{mycode_aiagent-0.4.0 → mycode_aiagent-0.4.2}/mycode_aiagent.egg-info/SOURCES.txt

@@ -12,7 +12,6 @@ my_code/backends/base.py
 my_code/backends/claude_backend.py
 my_code/backends/mcp_backend.py
 my_code/backends/openai_backend.py
-my_code/backends/ricky_backend.py
 my_code/utils/__init__.py
 my_code/utils/prompts.py
 mycode_aiagent.egg-info/PKG-INFO
@@ -21,4 +20,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.4.0 → mycode_aiagent-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mycode-aiagent"
-version = "0.4.0"
+version = "0.4.2"
 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.2/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()

mycode_aiagent-0.4.0/my_code/backends/ricky_backend.py

@@ -1,15 +0,0 @@
-from .base import AIBackend
-from ..mcp_client import MCPClient
-
-
-class RickyBackend(AIBackend):
-    max_file_chars: int = 1500
-
-    def __init__(self, url: str = "http://localhost:8000/mcp", timeout: int = 120):
-        self._client = MCPClient(url=url, timeout=timeout)
-
-    def ask_for_code(self, prompt: str) -> str:
-        return self._client.ask_for_code(prompt)
-
-    def ask_to_analyze(self, prompt: str) -> str:
-        return self._client.ask_to_analyze(prompt)