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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.4.0
+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"
 ```
 
 ---
@@ -364,6 +374,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,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.4.0 → 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"
 ```
 
 ---
@@ -335,6 +345,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,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.4.0 → mycode_aiagent-0.4.1}/my_code/cli.py

@@ -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,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,
@@ -52,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,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.4.0
+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"
 ```
 
 ---
@@ -364,6 +374,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,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.4.0 → 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.4.0 → mycode_aiagent-0.4.1}/pyproject.toml

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