mycode-aiagent 0.2.1__tar.gz → 0.3.0__tar.gz

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.2.1
+Version: 0.3.0
 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
@@ -242,6 +242,10 @@ Commands:
     --verbose     Print each file as it is analyzed
 
   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)
 ```
 
 ---
@@ -302,6 +306,77 @@ code = generate_code("write a logging helper", backend, profile)
 
 ---
 
+## Running as an MCP Server
+
+MyCode can expose itself as an MCP server so any MCP-compatible agent or orchestrator can call its tools directly — no MCP knowledge required.
+
+### Quick start
+
+```bash
+# Local LLM backend (default)
+my-code serve
+
+# Claude backend
+my-code --backend claude serve --port 8080
+
+# OpenAI backend
+my-code --backend openai serve --port 8080
+
+# Bind on all interfaces
+my-code --backend claude serve --host 0.0.0.0 --port 8080
+```
+
+On startup the server prints the URL and the config snippet to paste:
+
+```
+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"}}
+```
+
+### Connecting from an MCP consumer
+
+Add the printed snippet to your consumer's MCP config file (e.g. `.mcp.json`):
+
+```json
+{
+  "mycode": { "url": "http://127.0.0.1:8080/mcp" }
+}
+```
+
+### Tools exposed
+
+| Tool | Required args | Optional args |
+|------|--------------|---------------|
+| `analyze_codebase` | `path` — directory to analyze | `save_to` — path to save the profile JSON |
+| `generate_code` | `task` — what to write | `profile` — inline profile object; `profile_path` — path to a saved profile (default: `style_profile.json`) |
+
+Both tools return plain text. `analyze_codebase` returns the style profile as a JSON string. `generate_code` returns the generated source code.
+
+### Programmatic usage
+
+```python
+from my_code import run_server, make_backend
+
+# Blocking — call from a background thread if needed
+run_server(backend=make_backend("claude"), host="127.0.0.1", port=8080)
+```
+
+Or use `MCPServer` directly for more control:
+
+```python
+from my_code import MCPServer, make_backend
+import threading
+
+server = MCPServer(make_backend("claude"), host="127.0.0.1", port=8080)
+httpd = server.start()                          # binds immediately
+port = httpd.server_address[1]                  # actual port (useful when port=0)
+t = threading.Thread(target=httpd.serve_forever, daemon=True)
+t.start()
+# ... httpd.shutdown() to stop
+```
+
+---
+
 ## Deep Analysis
 
 For a richer style profile, `scripts/deep_analyze.py` runs six focused queries (naming, error handling, string formatting, module structure, docstrings, and representative snippets) and synthesizes them into a single detailed profile.
@@ -318,10 +393,16 @@ This is slower than the standard `analyze` command but produces a more detailed
 ## Running Tests
 
 ```bash
+# Library smoke tests (analyze → generate pipeline)
 python tests/test_library.py
+
+# MCP server protocol tests
+python -m pytest tests/test_server.py -v
+# or
+python -m unittest tests/test_server.py
 ```
 
-The test suite uses a `MockBackend` so no live AI backend is required. It exercises the full analyze → generate pipeline.
+Both test suites use a `MockBackend` — no live AI backend required.
 
 ---
 
@@ -332,17 +413,19 @@ 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)
+├── 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   # Placeholder for custom MCP backends
+│   └── mcp_backend.py   # Generic MCP server backend
 └── utils/
     └── prompts.py       # Prompt templates for extraction, summary, generation
 scripts/
 └── deep_analyze.py      # Multi-query deep style analysis
 tests/
-└── test_library.py      # Smoke tests (no live backend required)
+├── test_library.py      # Smoke tests for analyze/generate (no live backend)
+└── test_server.py       # MCP server protocol tests (no live backend)
 ```

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/README.md

@@ -213,6 +213,10 @@ Commands:
     --verbose     Print each file as it is analyzed
 
   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)
 ```
 
 ---
@@ -273,6 +277,77 @@ code = generate_code("write a logging helper", backend, profile)
 
 ---
 
+## Running as an MCP Server
+
+MyCode can expose itself as an MCP server so any MCP-compatible agent or orchestrator can call its tools directly — no MCP knowledge required.
+
+### Quick start
+
+```bash
+# Local LLM backend (default)
+my-code serve
+
+# Claude backend
+my-code --backend claude serve --port 8080
+
+# OpenAI backend
+my-code --backend openai serve --port 8080
+
+# Bind on all interfaces
+my-code --backend claude serve --host 0.0.0.0 --port 8080
+```
+
+On startup the server prints the URL and the config snippet to paste:
+
+```
+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"}}
+```
+
+### Connecting from an MCP consumer
+
+Add the printed snippet to your consumer's MCP config file (e.g. `.mcp.json`):
+
+```json
+{
+  "mycode": { "url": "http://127.0.0.1:8080/mcp" }
+}
+```
+
+### Tools exposed
+
+| Tool | Required args | Optional args |
+|------|--------------|---------------|
+| `analyze_codebase` | `path` — directory to analyze | `save_to` — path to save the profile JSON |
+| `generate_code` | `task` — what to write | `profile` — inline profile object; `profile_path` — path to a saved profile (default: `style_profile.json`) |
+
+Both tools return plain text. `analyze_codebase` returns the style profile as a JSON string. `generate_code` returns the generated source code.
+
+### Programmatic usage
+
+```python
+from my_code import run_server, make_backend
+
+# Blocking — call from a background thread if needed
+run_server(backend=make_backend("claude"), host="127.0.0.1", port=8080)
+```
+
+Or use `MCPServer` directly for more control:
+
+```python
+from my_code import MCPServer, make_backend
+import threading
+
+server = MCPServer(make_backend("claude"), host="127.0.0.1", port=8080)
+httpd = server.start()                          # binds immediately
+port = httpd.server_address[1]                  # actual port (useful when port=0)
+t = threading.Thread(target=httpd.serve_forever, daemon=True)
+t.start()
+# ... httpd.shutdown() to stop
+```
+
+---
+
 ## Deep Analysis
 
 For a richer style profile, `scripts/deep_analyze.py` runs six focused queries (naming, error handling, string formatting, module structure, docstrings, and representative snippets) and synthesizes them into a single detailed profile.
@@ -289,10 +364,16 @@ This is slower than the standard `analyze` command but produces a more detailed
 ## Running Tests
 
 ```bash
+# Library smoke tests (analyze → generate pipeline)
 python tests/test_library.py
+
+# MCP server protocol tests
+python -m pytest tests/test_server.py -v
+# or
+python -m unittest tests/test_server.py
 ```
 
-The test suite uses a `MockBackend` so no live AI backend is required. It exercises the full analyze → generate pipeline.
+Both test suites use a `MockBackend` — no live AI backend required.
 
 ---
 
@@ -303,17 +384,19 @@ 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)
+├── 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   # Placeholder for custom MCP backends
+│   └── mcp_backend.py   # Generic MCP server backend
 └── utils/
     └── prompts.py       # Prompt templates for extraction, summary, generation
 scripts/
 └── deep_analyze.py      # Multi-query deep style analysis
 tests/
-└── test_library.py      # Smoke tests (no live backend required)
+├── test_library.py      # Smoke tests for analyze/generate (no live backend)
+└── test_server.py       # MCP server protocol tests (no live backend)
 ```

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/my_code/__init__.py

@@ -1,8 +1,15 @@
-__version__ = "0.1.5"
+__version__ = "0.3.0"
 
 from .analyzer import StyleAnalyzer
 from .generator import generate_code
 from .backends import AIBackend, ClaudeBackend, OpenAIBackend, RickyBackend, MCPBackend, make_backend
+from .server import MCPServer
+
+
+def run_server(backend=None, host: str = "127.0.0.1", port: int = 8080):
+    """Start a blocking MCP server exposing analyze_codebase and generate_code as tools."""
+    MCPServer(backend or make_backend(), host=host, port=port).run()
+
 
 __all__ = [
     "StyleAnalyzer",
@@ -13,4 +20,6 @@ __all__ = [
     "RickyBackend",
     "MCPBackend",
     "make_backend",
+    "MCPServer",
+    "run_server",
 ]

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/my_code/cli.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from .analyzer import StyleAnalyzer
 from .backends import make_backend
 from .generator import generate_code
+from .server import MCPServer
 
 DEFAULT_PROFILE = Path("style_profile.json")
 
@@ -64,6 +65,18 @@ def cmd_generate(args):
     print(code)
 
 
+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,
+    )
+    MCPServer(backend, host=args.host, port=args.port, default_profile=args.profile).run()
+
+
 def main():
     parser = argparse.ArgumentParser(description="Style-aware code agent")
     parser.add_argument(
@@ -88,6 +101,11 @@ def main():
     p_gen.add_argument("task", help="Description of what to write")
     p_gen.set_defaults(func=cmd_generate)
 
+    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.set_defaults(func=cmd_serve)
+
     args = parser.parse_args()
     args.func(args)
 

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/my_code/mcp_client.py

@@ -104,9 +104,26 @@ class MCPClient:
         if isinstance(content, list):
             for block in content:
                 if block.get("type") == "text":
-                    return block.get("text", "")
+                    return self._unwrap_llm_response(block.get("text", ""))
         return str(content)
 
+    @staticmethod
+    def _unwrap_llm_response(text: str) -> str:
+        try:
+            data = json.loads(text)
+            if isinstance(data, dict) and "choices" in data:
+                choices = data["choices"]
+                if choices:
+                    choice = choices[0]
+                    if "text" in choice:
+                        return choice["text"]
+                    content = choice.get("message", {}).get("content")
+                    if content:
+                        return content
+        except (json.JSONDecodeError, KeyError, IndexError):
+            pass
+        return text
+
     def ask_for_code(self, prompt: str) -> str:
         result = self._post("tools/call", {
             "name": self._tool_name,

mycode_aiagent-0.3.0/my_code/server.py

@@ -0,0 +1,166 @@
+import json
+import uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+from .analyzer import StyleAnalyzer
+from .generator import generate_code as _generate_code
+
+_PROTOCOL = "2024-11-05"
+
+_TOOLS = [
+    {
+        "name": "analyze_codebase",
+        "description": "Analyze a codebase directory and extract its coding style profile.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "Path to the codebase directory to analyze.",
+                },
+                "save_to": {
+                    "type": "string",
+                    "description": "Optional path to save the resulting profile JSON file.",
+                },
+            },
+            "required": ["path"],
+        },
+    },
+    {
+        "name": "generate_code",
+        "description": "Generate Python code that matches a saved style profile.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "task": {
+                    "type": "string",
+                    "description": "Description of what code to write.",
+                },
+                "profile": {
+                    "type": "object",
+                    "description": "Inline style profile object — takes precedence over profile_path.",
+                },
+                "profile_path": {
+                    "type": "string",
+                    "description": "Path to a saved style_profile.json (default: style_profile.json).",
+                },
+            },
+            "required": ["task"],
+        },
+    },
+]
+
+
+class _MCPError(Exception):
+    def __init__(self, code: int, message: str):
+        self.code = code
+        self.message = message
+
+
+class _MCPRequestHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        if self.path != "/mcp":
+            self._send_sse({"jsonrpc": "2.0", "id": None, "error": {"code": -32600, "message": "Not found"}}, 404)
+            return
+
+        length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(length)
+        try:
+            msg = json.loads(body)
+        except json.JSONDecodeError:
+            self._send_sse({"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "Parse error"}}, 400)
+            return
+
+        req_id = msg.get("id")
+        method = msg.get("method", "")
+        params = msg.get("params", {})
+
+        try:
+            result, extra_headers = self.server.mcp._handle(method, params)
+            self._send_sse({"jsonrpc": "2.0", "id": req_id, "result": result}, 200, extra_headers)
+        except _MCPError as e:
+            self._send_sse({"jsonrpc": "2.0", "id": req_id, "error": {"code": e.code, "message": e.message}}, 200)
+        except Exception as e:
+            self._send_sse({"jsonrpc": "2.0", "id": req_id, "error": {"code": -32603, "message": str(e)}}, 200)
+
+    def _send_sse(self, data: dict, status: int = 200, extra_headers: dict | None = None):
+        body = f"data: {json.dumps(data)}\n\n".encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Content-Length", str(len(body)))
+        if extra_headers:
+            for k, v in extra_headers.items():
+                self.send_header(k, v)
+        self.end_headers()
+        self.wfile.write(body)
+
+    def log_message(self, format, *args):
+        pass
+
+
+class MCPServer:
+    def __init__(self, backend, host: str = "127.0.0.1", port: int = 8080, default_profile: str = "style_profile.json"):
+        self._backend = backend
+        self._host = host
+        self._port = port
+        self._default_profile = default_profile
+
+    def _handle(self, method: str, params: dict) -> tuple[dict, dict | None]:
+        if method == "initialize":
+            return self._initialize(), {"Mcp-Session-Id": str(uuid.uuid4())}
+        if method == "tools/list":
+            return {"tools": _TOOLS}, None
+        if method == "tools/call":
+            name = params.get("name", "")
+            arguments = params.get("arguments", {})
+            text = self._call_tool(name, arguments)
+            return {"content": [{"type": "text", "text": text}]}, None
+        raise _MCPError(-32601, f"Method not found: {method}")
+
+    def _initialize(self) -> dict:
+        return {
+            "protocolVersion": _PROTOCOL,
+            "capabilities": {"tools": {}},
+            "serverInfo": {"name": "mycode", "version": "0.3.0"},
+        }
+
+    def _call_tool(self, name: str, args: dict) -> str:
+        if name == "analyze_codebase":
+            return self._analyze(args)
+        if name == "generate_code":
+            return self._generate(args)
+        raise _MCPError(-32602, f"Unknown tool: {name}")
+
+    def _analyze(self, args: dict) -> str:
+        path = Path(args["path"]).resolve()
+        profile = StyleAnalyzer(self._backend).analyze_codebase(path)
+        save_to = args.get("save_to")
+        if save_to:
+            StyleAnalyzer.save_profile(profile, Path(save_to))
+        return json.dumps(profile, indent=2)
+
+    def _generate(self, args: dict) -> str:
+        task = args["task"]
+        profile = args.get("profile")
+        if profile is None:
+            profile_path = Path(args.get("profile_path") or self._default_profile)
+            profile = StyleAnalyzer.load_profile(profile_path)
+        return _generate_code(task=task, backend=self._backend, profile=profile)
+
+    def start(self) -> ThreadingHTTPServer:
+        httpd = ThreadingHTTPServer((self._host, self._port), _MCPRequestHandler)
+        httpd.mcp = self
+        return httpd
+
+    def run(self):
+        httpd = self.start()
+        host, port = httpd.server_address
+        print(f"MyCode MCP server running at http://{host}:{port}/mcp")
+        print(f'Add to your MCP config:  {{"mycode": {{"url": "http://{host}:{port}/mcp"}}}}')
+        try:
+            httpd.serve_forever()
+        except KeyboardInterrupt:
+            pass
+        finally:
+            httpd.server_close()

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/mycode_aiagent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-aiagent
-Version: 0.2.1
+Version: 0.3.0
 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
@@ -242,6 +242,10 @@ Commands:
     --verbose     Print each file as it is analyzed
 
   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)
 ```
 
 ---
@@ -302,6 +306,77 @@ code = generate_code("write a logging helper", backend, profile)
 
 ---
 
+## Running as an MCP Server
+
+MyCode can expose itself as an MCP server so any MCP-compatible agent or orchestrator can call its tools directly — no MCP knowledge required.
+
+### Quick start
+
+```bash
+# Local LLM backend (default)
+my-code serve
+
+# Claude backend
+my-code --backend claude serve --port 8080
+
+# OpenAI backend
+my-code --backend openai serve --port 8080
+
+# Bind on all interfaces
+my-code --backend claude serve --host 0.0.0.0 --port 8080
+```
+
+On startup the server prints the URL and the config snippet to paste:
+
+```
+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"}}
+```
+
+### Connecting from an MCP consumer
+
+Add the printed snippet to your consumer's MCP config file (e.g. `.mcp.json`):
+
+```json
+{
+  "mycode": { "url": "http://127.0.0.1:8080/mcp" }
+}
+```
+
+### Tools exposed
+
+| Tool | Required args | Optional args |
+|------|--------------|---------------|
+| `analyze_codebase` | `path` — directory to analyze | `save_to` — path to save the profile JSON |
+| `generate_code` | `task` — what to write | `profile` — inline profile object; `profile_path` — path to a saved profile (default: `style_profile.json`) |
+
+Both tools return plain text. `analyze_codebase` returns the style profile as a JSON string. `generate_code` returns the generated source code.
+
+### Programmatic usage
+
+```python
+from my_code import run_server, make_backend
+
+# Blocking — call from a background thread if needed
+run_server(backend=make_backend("claude"), host="127.0.0.1", port=8080)
+```
+
+Or use `MCPServer` directly for more control:
+
+```python
+from my_code import MCPServer, make_backend
+import threading
+
+server = MCPServer(make_backend("claude"), host="127.0.0.1", port=8080)
+httpd = server.start()                          # binds immediately
+port = httpd.server_address[1]                  # actual port (useful when port=0)
+t = threading.Thread(target=httpd.serve_forever, daemon=True)
+t.start()
+# ... httpd.shutdown() to stop
+```
+
+---
+
 ## Deep Analysis
 
 For a richer style profile, `scripts/deep_analyze.py` runs six focused queries (naming, error handling, string formatting, module structure, docstrings, and representative snippets) and synthesizes them into a single detailed profile.
@@ -318,10 +393,16 @@ This is slower than the standard `analyze` command but produces a more detailed
 ## Running Tests
 
 ```bash
+# Library smoke tests (analyze → generate pipeline)
 python tests/test_library.py
+
+# MCP server protocol tests
+python -m pytest tests/test_server.py -v
+# or
+python -m unittest tests/test_server.py
 ```
 
-The test suite uses a `MockBackend` so no live AI backend is required. It exercises the full analyze → generate pipeline.
+Both test suites use a `MockBackend` — no live AI backend required.
 
 ---
 
@@ -332,17 +413,19 @@ 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)
+├── 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   # Placeholder for custom MCP backends
+│   └── mcp_backend.py   # Generic MCP server backend
 └── utils/
     └── prompts.py       # Prompt templates for extraction, summary, generation
 scripts/
 └── deep_analyze.py      # Multi-query deep style analysis
 tests/
-└── test_library.py      # Smoke tests (no live backend required)
+├── test_library.py      # Smoke tests for analyze/generate (no live backend)
+└── test_server.py       # MCP server protocol tests (no live backend)
 ```

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/mycode_aiagent.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ my_code/analyzer.py
 my_code/cli.py
 my_code/generator.py
 my_code/mcp_client.py
+my_code/server.py
 my_code/backends/__init__.py
 my_code/backends/base.py
 my_code/backends/claude_backend.py

{mycode_aiagent-0.2.1 → mycode_aiagent-0.3.0}/pyproject.toml

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