mycode-aiagent 0.1.0__py3-none-any.whl

my_code/__init__.py

@@ -0,0 +1,16 @@
+__version__ = "0.1.0"
+
+from .analyzer import StyleAnalyzer
+from .generator import generate_code
+from .backends import AIBackend, ClaudeBackend, OpenAIBackend, RickyBackend, MCPBackend, make_backend
+
+__all__ = [
+    "StyleAnalyzer",
+    "generate_code",
+    "AIBackend",
+    "ClaudeBackend",
+    "OpenAIBackend",
+    "RickyBackend",
+    "MCPBackend",
+    "make_backend",
+]

my_code/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

my_code/analyzer.py

@@ -0,0 +1,84 @@
+import json
+import re
+from pathlib import Path
+
+from .backends import AIBackend
+from .utils.prompts import STYLE_EXTRACTION_PROMPT, STYLE_SUMMARY_PROMPT
+
+_SKIP_DIRS = {"__pycache__", ".git", ".venv", "venv", "node_modules", "dist", "build"}
+
+
+def _collect_python_files(root: Path) -> list[Path]:
+    files = []
+    for path in root.rglob("*.py"):
+        if not any(part in _SKIP_DIRS for part in path.parts):
+            files.append(path)
+    return sorted(files)
+
+
+def _extract_json(text: str) -> dict:
+    # Claude/OpenAI return clean JSON; llama wraps it in prose
+    try:
+        return json.loads(text.strip())
+    except json.JSONDecodeError:
+        pass
+    match = re.search(r"\{.*\}", text, re.DOTALL)
+    if not match:
+        raise ValueError(f"No JSON found in response:\n{text[:300]}")
+    return json.loads(match.group())
+
+
+class StyleAnalyzer:
+    def __init__(self, backend: AIBackend):
+        self.backend = backend
+
+    def analyze_file(self, path: Path) -> dict:
+        source = path.read_text(encoding="utf-8", errors="ignore")[:self.backend.max_file_chars]
+        if not source.strip():
+            return {}
+        prompt = STYLE_EXTRACTION_PROMPT.format(filename=path.name, source=source)
+        raw = self.backend.ask_to_analyze(prompt)
+        try:
+            return _extract_json(raw)
+        except (ValueError, json.JSONDecodeError) as e:
+            print(f"  [warn] Could not parse style from {path.name}: {e}")
+            return {}
+
+    def analyze_codebase(self, root: Path, verbose: bool = False) -> dict:
+        files = _collect_python_files(root)
+        if not files:
+            raise FileNotFoundError(f"No Python files found under {root}")
+
+        observations = []
+        for path in files:
+            rel = path.relative_to(root)
+            if verbose:
+                print(f"  Analyzing {rel} ...")
+            obs = self.analyze_file(path)
+            if obs:
+                observations.append(obs)
+
+        if not observations:
+            raise RuntimeError("No style data could be extracted from any file.")
+
+        if len(observations) == 1:
+            return observations[0]
+
+        prompt = STYLE_SUMMARY_PROMPT.format(
+            observations=json.dumps(observations, indent=2)
+        )
+        raw = self.backend.ask_to_analyze(prompt)
+        try:
+            return _extract_json(raw)
+        except (ValueError, json.JSONDecodeError) as e:
+            print(f"[warn] Could not synthesize profile, using first observation: {e}")
+            return observations[0]
+
+    @staticmethod
+    def save_profile(profile: dict, path: Path):
+        path.write_text(json.dumps(profile, indent=2), encoding="utf-8")
+        print(f"Style profile saved to {path}")
+
+    @staticmethod
+    def load_profile(path: Path) -> dict:
+        return json.loads(path.read_text(encoding="utf-8"))

my_code/backends/__init__.py

@@ -0,0 +1,33 @@
+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"]
+
+
+def make_backend(
+    backend: str = "llama",
+    api_key: str | None = None,
+    ricky_url: str = "http://localhost:8000/mcp",
+    mcp_url: str = "http://localhost:8001/mcp",
+    model: str | None = None,
+) -> AIBackend:
+    if backend == "claude":
+        key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+        if not key:
+            raise ValueError("Claude backend requires ANTHROPIC_API_KEY or --api-key")
+        return ClaudeBackend(api_key=key, **{"model": model} if model else {})
+    if backend == "openai":
+        key = api_key or os.environ.get("OPENAI_API_KEY")
+        if not key:
+            raise ValueError("OpenAI backend requires OPENAI_API_KEY or --api-key")
+        return OpenAIBackend(api_key=key, **{"model": model} if model else {})
+    if backend == "mcp":
+        return MCPBackend(url=mcp_url)
+    if backend == "llama":
+        return RickyBackend(url=ricky_url)
+    raise ValueError(f"Unknown backend {backend!r}. Choose: llama, claude, openai, mcp")

my_code/backends/base.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+
+class AIBackend(ABC):
+    max_file_chars: int = 6000
+
+    @abstractmethod
+    def ask_for_code(self, prompt: str) -> str:
+        pass
+
+    @abstractmethod
+    def ask_to_analyze(self, prompt: str) -> str:
+        pass

my_code/backends/claude_backend.py

@@ -0,0 +1,32 @@
+from .base import AIBackend
+
+
+class ClaudeBackend(AIBackend):
+    def __init__(self, api_key: str, model: str = "claude-opus-4-7"):
+        try:
+            import anthropic
+        except ImportError:
+            raise ImportError("Claude backend requires 'anthropic': pip install 'my-code[claude]'")
+        self._client = anthropic.Anthropic(api_key=api_key)
+        self._model = model
+
+    def _call(self, system: str, prompt: str) -> str:
+        response = self._client.messages.create(
+            model=self._model,
+            max_tokens=2048,
+            system=system,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        return response.content[0].text
+
+    def ask_for_code(self, prompt: str) -> str:
+        return self._call(
+            "You are an expert Python developer. Return only Python code, no explanation.",
+            prompt,
+        )
+
+    def ask_to_analyze(self, prompt: str) -> str:
+        return self._call(
+            "You are a code style analyst. Return only valid JSON, no explanation.",
+            prompt,
+        )

my_code/backends/mcp_backend.py

@@ -0,0 +1,14 @@
+from .base import AIBackend
+
+_MSG = "MCPBackend is not yet configured. Set the MCP server URL and implement this backend."
+
+
+class MCPBackend(AIBackend):
+    def __init__(self, url: str = "http://localhost:8001/mcp"):
+        self.url = url
+
+    def ask_for_code(self, prompt: str) -> str:
+        raise NotImplementedError(_MSG)
+
+    def ask_to_analyze(self, prompt: str) -> str:
+        raise NotImplementedError(_MSG)

my_code/backends/openai_backend.py

@@ -0,0 +1,33 @@
+from .base import AIBackend
+
+
+class OpenAIBackend(AIBackend):
+    def __init__(self, api_key: str, model: str = "gpt-4o"):
+        try:
+            import openai
+        except ImportError:
+            raise ImportError("OpenAI backend requires 'openai': pip install 'my-code[openai]'")
+        self._client = openai.OpenAI(api_key=api_key)
+        self._model = model
+
+    def _call(self, system: str, prompt: str) -> str:
+        response = self._client.chat.completions.create(
+            model=self._model,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ],
+        )
+        return response.choices[0].message.content
+
+    def ask_for_code(self, prompt: str) -> str:
+        return self._call(
+            "You are an expert Python developer. Return only Python code, no explanation.",
+            prompt,
+        )
+
+    def ask_to_analyze(self, prompt: str) -> str:
+        return self._call(
+            "You are a code style analyst. Return only valid JSON, no explanation.",
+            prompt,
+        )

my_code/backends/ricky_backend.py

@@ -0,0 +1,15 @@
+from .base import AIBackend
+from ..ricky_client import RickyClient
+
+
+class RickyBackend(AIBackend):
+    max_file_chars: int = 1500
+
+    def __init__(self, url: str = "http://localhost:8000/mcp"):
+        self._client = RickyClient(url=url)
+
+    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)

my_code/cli.py

@@ -0,0 +1,93 @@
+"""
+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>"
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .analyzer import StyleAnalyzer
+from .backends import make_backend
+from .generator import generate_code
+
+DEFAULT_PROFILE = Path("style_profile.json")
+
+
+def cmd_analyze(args):
+    root = Path(args.codebase).resolve()
+    if not root.exists():
+        sys.exit(f"Error: directory not found: {root}")
+
+    backend = make_backend(
+        backend=args.backend,
+        api_key=args.api_key,
+        ricky_url=args.ricky_url,
+        mcp_url=args.mcp_url,
+        model=args.model,
+    )
+
+    print(f"Analyzing codebase at {root} ...")
+    analyzer = StyleAnalyzer(backend)
+    profile = analyzer.analyze_codebase(root, verbose=args.verbose)
+
+    out = Path(args.profile)
+    StyleAnalyzer.save_profile(profile, out)
+
+
+def cmd_generate(args):
+    profile_path = Path(args.profile)
+    if not profile_path.exists():
+        sys.exit(
+            f"Error: style profile not found at {profile_path}. "
+            "Run 'analyze' first."
+        )
+
+    backend = make_backend(
+        backend=args.backend,
+        api_key=args.api_key,
+        ricky_url=args.ricky_url,
+        mcp_url=args.mcp_url,
+        model=args.model,
+    )
+
+    profile = json.loads(profile_path.read_text(encoding="utf-8"))
+
+    print("Generating code ...\n")
+    code = generate_code(task=args.task, backend=backend, profile=profile)
+    print(code)
+
+
+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)",
+    )
+    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("--profile", default=str(DEFAULT_PROFILE))
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_analyze = sub.add_parser("analyze", help="Analyze a codebase and save a style profile")
+    p_analyze.add_argument("codebase", help="Path to the codebase directory")
+    p_analyze.add_argument("-v", "--verbose", action="store_true")
+    p_analyze.set_defaults(func=cmd_analyze)
+
+    p_gen = sub.add_parser("generate", help="Generate code matching the saved style profile")
+    p_gen.add_argument("task", help="Description of what to write")
+    p_gen.set_defaults(func=cmd_generate)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

my_code/generator.py

@@ -0,0 +1,13 @@
+import json
+
+from .backends.base import AIBackend
+from .utils.prompts import CODE_GENERATION_PROMPT
+
+
+def generate_code(task: str, backend: AIBackend, profile: dict) -> str:
+    """Generate Python code matching the given style profile."""
+    prompt = CODE_GENERATION_PROMPT.format(
+        style_profile=json.dumps(profile, indent=2),
+        task=task,
+    )
+    return backend.ask_for_code(prompt)

my_code/ricky_client.py

@@ -0,0 +1,112 @@
+import json
+import uuid
+
+import requests
+
+# Ricky's own instructions: give it explicit, complete prompts.
+_PROTOCOL = "2024-11-05"
+
+
+def _parse_sse_result(text: str) -> dict:
+    """Extract the first JSON-RPC result/error from an SSE response body."""
+    for line in text.splitlines():
+        if line.startswith("data:"):
+            payload = line[5:].strip()
+            if payload and payload != "[DONE]":
+                return json.loads(payload)
+    raise ValueError(f"No data event in SSE body:\n{text[:400]}")
+
+
+class RickyClient:
+    """MCP client for ricky using the Streamable HTTP transport.
+
+    Flow:
+      1. POST /mcp  initialize  → SSE body + Mcp-Session-Id header
+      2. POST /mcp  <any call>  → SSE body  (Mcp-Session-Id in every request)
+    """
+
+    def __init__(self, url: str = "http://localhost:8000/mcp"):
+        self.url = url
+        self._session_id: str | None = None
+        self._tool_name: str | None = None
+        self._tool_name_analyze: str | None = None
+        self._initialize()
+        self._discover_tools()
+        print(f"Connected to ricky — tools: '{self._tool_name}', '{self._tool_name_analyze}'")
+
+    def _post(self, method: str, params: dict, timeout: int = 120) -> dict:
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+        }
+        if self._session_id:
+            headers["Mcp-Session-Id"] = self._session_id
+
+        payload = {
+            "jsonrpc": "2.0",
+            "id": str(uuid.uuid4()),
+            "method": method,
+            "params": params,
+        }
+        resp = requests.post(self.url, json=payload, headers=headers, timeout=timeout)
+        resp.raise_for_status()
+
+        if "Mcp-Session-Id" in resp.headers:
+            self._session_id = resp.headers["Mcp-Session-Id"]
+
+        msg = _parse_sse_result(resp.text)
+        if "error" in msg:
+            raise RuntimeError(f"MCP error ({method}): {msg['error']}")
+        return msg.get("result", {})
+
+    def _initialize(self):
+        self._post("initialize", {
+            "protocolVersion": _PROTOCOL,
+            "capabilities": {},
+            "clientInfo": {"name": "style-agent", "version": "1.0"},
+        })
+
+    def _discover_tools(self):
+        tools = self._post("tools/list", {}).get("tools", [])
+        if not tools:
+            raise RuntimeError("Ricky exposes no tools")
+        for t in tools:
+            name = t["name"]
+            if "analyze" in name and self._tool_name_analyze is None:
+                self._tool_name_analyze = name
+            elif self._tool_name is None:
+                self._tool_name = name
+        if not self._tool_name:
+            raise RuntimeError("Ricky exposes no coding tool")
+        if not self._tool_name_analyze:
+            raise RuntimeError("Ricky exposes no analyze tool")
+
+    def _parse_content(self, result: dict) -> str:
+        content = result.get("content", [])
+        if isinstance(content, list):
+            for block in content:
+                if block.get("type") == "text":
+                    text = block.get("text", "")
+                    # Ricky wraps llama.cpp output: {"result": "<completion JSON>"}
+                    try:
+                        outer = json.loads(text)
+                        inner_str = outer.get("result", text)
+                        inner = json.loads(inner_str)
+                        return inner["choices"][0]["text"]
+                    except (json.JSONDecodeError, KeyError, TypeError):
+                        return text
+        return str(content)
+
+    def ask_for_code(self, prompt: str) -> str:
+        result = self._post("tools/call", {
+            "name": self._tool_name,
+            "arguments": {"query": prompt},
+        })
+        return self._parse_content(result)
+
+    def ask_to_analyze(self, prompt: str) -> str:
+        result = self._post("tools/call", {
+            "name": self._tool_name_analyze,
+            "arguments": {"query": prompt},
+        }, timeout=600)
+        return self._parse_content(result)

my_code/utils/prompts.py

@@ -0,0 +1,58 @@
+STYLE_EXTRACTION_PROMPT = """\
+You are a code style analyst. Analyze the following Python source file and return a JSON object describing its style. Be precise and concise.
+
+Return ONLY valid JSON with this exact schema:
+{{
+  "naming": {{
+    "functions": "<snake_case|camelCase|PascalCase|other>",
+    "classes": "<snake_case|camelCase|PascalCase|other>",
+    "variables": "<snake_case|camelCase|PascalCase|other>",
+    "constants": "<UPPER_SNAKE_CASE|other>",
+    "notes": "<any notable patterns, e.g. verb_noun for functions, single-letter loop vars, etc.>"
+  }},
+  "structure": {{
+    "import_style": "<grouped|flat|alphabetical|none>",
+    "class_method_order": "<init_first|alphabetical|public_then_private|none>",
+    "preferred_length": "<short|medium|long>",
+    "module_layout": "<description of top-level ordering>"
+  }},
+  "comments": {{
+    "docstring_style": "<Google|NumPy|reStructuredText|plain|none>",
+    "inline_density": "<sparse|moderate|heavy|none>",
+    "docstring_sections": [<list of sections used, e.g. "Args", "Returns", "Raises", "Example">]
+  }},
+  "representative_snippets": [<1-3 short verbatim code snippets that best show the style>]
+}}
+
+Source file ({filename}):
+```python
+{source}
+```
+"""
+
+STYLE_SUMMARY_PROMPT = """\
+You are a code style analyst. Below are JSON style observations extracted from multiple files in a codebase. Synthesize them into a single authoritative style profile JSON.
+
+Use the same schema. For fields where files disagree, pick the majority or most consistent value. Add a "confidence" field (low/medium/high) per section. Keep representative_snippets to the 3 best examples across all files.
+
+Return ONLY valid JSON.
+
+Observations:
+{observations}
+"""
+
+CODE_GENERATION_PROMPT = """\
+You are an expert Python developer. Write code that matches the style profile below exactly.
+
+Style profile:
+{style_profile}
+
+Task:
+{task}
+
+Rules:
+- Match naming conventions, docstring style, and comment density from the profile exactly.
+- Follow the module and class structure patterns.
+- Use the representative snippets as a style reference.
+- Return ONLY the Python code, no explanation.
+"""

mycode_aiagent-0.1.0.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: mycode-aiagent
+Version: 0.1.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
+Project-URL: Repository, https://github.com/RyanAbbottData/MyCode
+Project-URL: Issues, https://github.com/RyanAbbottData/MyCode/issues
+Keywords: code generation,style analysis,llm,ai,developer tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Provides-Extra: claude
+Requires-Dist: anthropic>=0.40; extra == "claude"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40; extra == "all"
+Requires-Dist: openai>=1.0; extra == "all"
+
+```
+ __  __        ____          _
+|  \/  |_   _ / ___|___   __| | ___
+| |\/| | | | | |   / _ \ / _` |/ _ \
+| |  | | |_| | |__| (_) | (_| |  __/
+|_|  |_|\__, |\____\___/ \__,_|\___|
+        |___/
+```
+
+> **Style-aware code generation.** Analyze any codebase to extract its coding style, then generate new code that matches it exactly.
+
+---
+
+## What it does
+
+MyCode learns how a developer or team writes code — naming conventions, type annotation style, import grouping, docstring format, error handling patterns — and uses that style profile to generate new code that feels like it was written by the same hand.
+
+It is built to slot into larger agentic systems: the analyzer and generator are clean library functions, and the backend is swappable (local LLM, Claude, or OpenAI).
+
+---
+
+## Requirements
+
+- Python 3.10+
+- A running AI backend (see [Backends](#backends))
+
+---
+
+## Installation
+
+```bash
+# Clone and install in editable mode
+git clone <repo-url>
+cd MyCode
+pip install -e .
+
+# For Claude backend support
+pip install -e ".[claude]"
+
+# For OpenAI backend support
+pip install -e ".[openai]"
+
+# For all backends
+pip install -e ".[all]"
+```
+
+The `my-code` CLI command is registered automatically on install.
+
+---
+
+## Backends
+
+MyCode delegates inference to a pluggable backend. Choose one based on what you have available.
+
+| 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` |
+| OpenAI | `--backend openai` | `OPENAI_API_KEY` env var or `--api-key` |
+| Custom MCP server | `--backend mcp` | Any MCP server at `--mcp-url` |
+
+### 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):
+
+**1. Download a model**
+
+A code-focused model works best. Good options:
+- [CodeLlama-7B-Instruct](https://huggingface.co/TheBloke/CodeLlama-7B-Instruct-GGUF) — fast, runs on most hardware
+- [CodeLlama-13B-Instruct](https://huggingface.co/TheBloke/CodeLlama-13B-Instruct-GGUF) — better quality, needs ~10 GB VRAM
+- [DeepSeek-Coder-6.7B-Instruct](https://huggingface.co/TheBloke/deepseek-coder-6.7B-instruct-GGUF) — strong alternative
+
+Download a `.gguf` quantized file (Q4_K_M is a good balance of size and quality).
+
+**2. Start the llama.cpp server**
+
+```bash
+# Install llama.cpp (or use a pre-built binary)
+pip install llama-cpp-python[server]
+
+# Start the OpenAI-compatible server
+python -m llama_cpp.server \
+  --model ./models/codellama-7b-instruct.Q4_K_M.gguf \
+  --host 0.0.0.0 \
+  --port 8000 \
+  --n_ctx 4096
+```
+
+**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:
+- A **code generation tool** (name must not contain `"analyze"`)
+- An **analysis tool** (name must contain `"analyze"`)
+
+Both tools accept a `query` string and return the model's completion. A minimal FastMCP wrapper example:
+
+```python
+# llm_mcp_server.py
+from fastmcp import FastMCP
+import requests
+
+mcp = FastMCP("local-llm")
+LLM_URL = "http://localhost:8000/v1/completions"
+
+def _complete(prompt: str) -> str:
+    resp = requests.post(LLM_URL, json={
+        "prompt": prompt,
+        "max_tokens": 1024,
+        "temperature": 0.1,
+    })
+    return resp.json()["choices"][0]["text"]
+
+@mcp.tool()
+def generate_code(query: str) -> str:
+    return _complete(query)
+
+@mcp.tool()
+def analyze_code(query: str) -> str:
+    return _complete(query)
+
+if __name__ == "__main__":
+    mcp.run(transport="streamable-http", host="0.0.0.0", port=8000)
+```
+
+```bash
+pip install fastmcp
+python llm_mcp_server.py
+```
+
+**4. Point MyCode at it**
+
+```bash
+my-code --backend llama --ricky-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 .
+```
+
+---
+
+## CLI Usage
+
+### Step 1 — Analyze a codebase
+
+Point MyCode at any directory. It reads every `.py` file and builds a style profile.
+
+```bash
+my-code analyze ./path/to/codebase
+```
+
+With verbose output:
+```bash
+my-code analyze ./path/to/codebase --verbose
+```
+
+Using a different backend:
+```bash
+my-code --backend claude analyze ./path/to/codebase
+my-code --backend openai --api-key sk-... analyze ./path/to/codebase
+```
+
+The profile is saved to `style_profile.json` by default. Specify a different path with `--profile`:
+```bash
+my-code analyze ./path/to/codebase --profile ./profiles/my_team.json
+```
+
+### Step 2 — Generate code
+
+```bash
+my-code generate "write a function that parses a CSV file and returns a list of dicts"
+```
+
+MyCode loads `style_profile.json` and instructs the backend to produce code that matches the analyzed style — naming, annotations, docstrings, structure and all.
+
+```bash
+# Use a specific profile
+my-code generate "write a retry decorator" --profile ./profiles/my_team.json
+
+# Use Claude to generate
+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"
+```
+
+---
+
+## CLI Reference
+
+```
+my-code [OPTIONS] COMMAND
+
+Options:
+  --backend {llama,claude,openai,mcp}   AI backend to use (default: llama)
+  --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)
+  --profile TEXT                         Path to style profile JSON (default: style_profile.json)
+
+Commands:
+  analyze PATH    Analyze a codebase and write a style profile
+    --verbose     Print each file as it is analyzed
+
+  generate TASK   Generate code matching the saved style profile
+```
+
+---
+
+## Python API
+
+MyCode is a first-class library. All CLI functionality is available programmatically.
+
+```python
+from my_code import StyleAnalyzer, generate_code, make_backend
+from pathlib import Path
+
+# Create a backend
+backend = make_backend()                           # local LLM (default)
+backend = make_backend("claude")                   # Claude (reads ANTHROPIC_API_KEY)
+backend = make_backend("openai", api_key="sk-...") # OpenAI
+
+# Analyze a codebase
+analyzer = StyleAnalyzer(backend)
+profile = analyzer.analyze_codebase(Path("./my_project"), verbose=True)
+
+# Save and reload the profile
+StyleAnalyzer.save_profile(profile, Path("style.json"))
+profile = StyleAnalyzer.load_profile(Path("style.json"))
+
+# Generate code
+code = generate_code(
+    task="write a function that validates an email address",
+    backend=backend,
+    profile=profile,
+)
+print(code)
+```
+
+### Bring your own backend
+
+Implement `AIBackend` to connect any model:
+
+```python
+from my_code import AIBackend, StyleAnalyzer, generate_code
+
+class MyBackend(AIBackend):
+    max_file_chars = 4000  # how much of each file to send for analysis
+
+    def ask_for_code(self, prompt: str) -> str:
+        # call your model, return the generated code as a string
+        ...
+
+    def ask_to_analyze(self, prompt: str) -> str:
+        # call your model, return a JSON string describing the style
+        ...
+
+backend = MyBackend()
+analyzer = StyleAnalyzer(backend)
+profile = analyzer.analyze_codebase(Path("."))
+code = generate_code("write a logging helper", backend, profile)
+```
+
+---
+
+## 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.
+
+```bash
+# Run from the project root; writes style_profile.json
+python scripts/deep_analyze.py
+```
+
+This is slower than the standard `analyze` command but produces a more detailed profile, which leads to better code generation.
+
+---
+
+## Running Tests
+
+```bash
+python tests/test_library.py
+```
+
+The test suite uses a `MockBackend` so no live AI backend is required. It exercises the full analyze → generate pipeline.
+
+---
+
+## Project Structure
+
+```
+my_code/
+├── analyzer.py          # StyleAnalyzer — scans files, builds style profile
+├── generator.py         # generate_code() — formats prompt and calls backend
+├── ricky_client.py      # Low-level MCP client for the local LLM server
+├── 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
+└── 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)
+```

mycode_aiagent-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+my_code/__init__.py,sha256=YCTHYVmOKP6TmIFDxnQDcc84K4N8AwqB6wGjn-H5vOU,372
+my_code/__main__.py,sha256=-vt2T7-_AnWJ8BTBSmJKPXmOZtpe6TkNXghJJ6dIP_o,63
+my_code/analyzer.py,sha256=-6auv6bbxe10ep_Y2T9uiq2qM7CLTU1M2nwRE7kN_rU,2850
+my_code/cli.py,sha256=H1QXPLLbsrqEkdxcjASrr4xwHbs8uGVOU81E7Rzr4U4,2985
+my_code/generator.py,sha256=R3FPVDNy-8YAMjyZyuLygLH913M2WAGE7q4BqvFdDXU,401
+my_code/ricky_client.py,sha256=irve8roLPQBtsEZMDBXKHL4JWt2Mv65ZMNYGlYGbLWw,4187
+my_code/backends/__init__.py,sha256=FjtrGB7y_3O_s1O81G5gICUUVcMHtnarY1BXP-uGmuU,1328
+my_code/backends/base.py,sha256=9hc6HaNcJSX8twRZM897teGONQWe3CcoltwzIjhdrkA,268
+my_code/backends/claude_backend.py,sha256=O37BnJXnOTzvRPIsWl07WtYElVH-Ov2cJKKt2T3jS_0,1082
+my_code/backends/mcp_backend.py,sha256=g2SAqMmL-_A5NEEouNE1l7XdiVyw3iMku-Ko4F3ZHp8,421
+my_code/backends/openai_backend.py,sha256=SneHFNQQKhq4hKZgN7WniyVgP9lJd6wK1vZaOIokCWw,1110
+my_code/backends/ricky_backend.py,sha256=EVXgWyjBEr5b9tY6wvTxQLUgXu70agPSuByo30TVKYM,440
+my_code/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+my_code/utils/prompts.py,sha256=azaC61hc9eaTSnGiFD0botw7-HoTMzQKawJ9X1YEa0w,2194
+mycode_aiagent-0.1.0.dist-info/METADATA,sha256=5apqZyJtbt_4iSDs89O6pu3fxUI1r2-eyoY6NKLmoS0,10916
+mycode_aiagent-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+mycode_aiagent-0.1.0.dist-info/entry_points.txt,sha256=-bGlti5BHHrdHW2XhcQW-W-gufCQek9PsczygeFZkXs,45
+mycode_aiagent-0.1.0.dist-info/top_level.txt,sha256=xAInreiHP8EP1o4MxvRhovZW9pZuinc3miY3ZNAnlJc,8
+mycode_aiagent-0.1.0.dist-info/RECORD,,

mycode_aiagent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mycode_aiagent-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+my-code = my_code.cli:main

mycode_aiagent-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+my_code