djcrud-client 0.3.1__tar.gz

djcrud_client-0.3.1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: djcrud-client
+Version: 0.3.1
+Summary: Stdio MCP bridge for djcrud JSON APIs (no Django required)
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp<2,>=1.0
+Requires-Dist: httpx>=0.27
+
+# djcrud-client
+
+Stdio MCP bridge for [djcrud](https://github.com/yourlabs/djcrud) JSON APIs. No Django required in the subprocess — FastMCP runs here, not on the Django host.
+
+## Install
+
+```bash
+pip install djcrud-client
+djcrud-client -mcp
+```
+
+## Host setup
+
+Declare `McpProfile` classes in your app's `djcrud.py` and register them on `djcrud_mcp.site` (see `djcrud_example/mcp_example/djcrud.py` in the djcrud repo).
+
+Add `djcrud_mcp` to `INSTALLED_APPS` and include `djcrud_drf.site` URLs on the host. Register one `McpProfile` in your app's `djcrud.py` (see `mcp_example/djcrud.py`). Run `djcrud-client -mcp` with `DJCRUD_TOKEN` set.

djcrud_client-0.3.1/README.md

@@ -0,0 +1,16 @@
+# djcrud-client
+
+Stdio MCP bridge for [djcrud](https://github.com/yourlabs/djcrud) JSON APIs. No Django required in the subprocess — FastMCP runs here, not on the Django host.
+
+## Install
+
+```bash
+pip install djcrud-client
+djcrud-client -mcp
+```
+
+## Host setup
+
+Declare `McpProfile` classes in your app's `djcrud.py` and register them on `djcrud_mcp.site` (see `djcrud_example/mcp_example/djcrud.py` in the djcrud repo).
+
+Add `djcrud_mcp` to `INSTALLED_APPS` and include `djcrud_drf.site` URLs on the host. Register one `McpProfile` in your app's `djcrud.py` (see `mcp_example/djcrud.py`). Run `djcrud-client -mcp` with `DJCRUD_TOKEN` set.

djcrud_client-0.3.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "djcrud-client"
+dynamic = ["version"]
+description = "Stdio MCP bridge for djcrud JSON APIs (no Django required)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+dependencies = [
+    "mcp>=1.0,<2",
+    "httpx>=0.27",
+]
+
+[project.scripts]
+djcrud-client = "djcrud_client.__main__:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools_scm]
+root = ".."
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = ["-ra", "--strict-markers"]

djcrud_client-0.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

djcrud_client-0.3.1/src/djcrud_client/__init__.py

@@ -0,0 +1,23 @@
+"""Stdio MCP bridge for djcrud JSON APIs (no Django required)."""
+
+from .api import CrudApi, login
+from .config import get_base_url, get_registry_key, get_token
+from .profile import McpProfile, profile_meta
+from .schema import all_tools_for_profile, build_tools_for_profile, build_tools_from_schema
+from .server import create_mcp_server, fetch_schema, run_stdio
+
+__all__ = [
+    "CrudApi",
+    "McpProfile",
+    "all_tools_for_profile",
+    "build_tools_for_profile",
+    "build_tools_from_schema",
+    "create_mcp_server",
+    "fetch_schema",
+    "get_base_url",
+    "get_registry_key",
+    "get_token",
+    "login",
+    "profile_meta",
+    "run_stdio",
+]

djcrud_client-0.3.1/src/djcrud_client/__main__.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from djcrud_client.api import CrudApi, login
+from djcrud_client.config import get_base_url, get_registry_key, get_token
+from djcrud_client.schema import all_tools_for_profile
+from djcrud_client.server import create_mcp_server, fetch_schema, load_profile
+from djcrud_client.tools import render_path, split_arguments
+
+
+def resolve_token(
+    *,
+    base_url: str,
+    username: str | None,
+    password: str | None,
+) -> str:
+    token = get_token()
+    if token:
+        return token
+    user = username or os.environ.get("DJCRUD_USERNAME", "").strip()
+    pwd = password or os.environ.get("DJCRUD_PASSWORD", "").strip()
+    if not user or not pwd:
+        raise SystemExit(
+            "Authentication required: set DJCRUD_TOKEN "
+            "or provide --user/--password (or DJCRUD_USERNAME/DJCRUD_PASSWORD)."
+        )
+    return login(base_url=base_url, username=user, password=pwd)
+
+
+def call_tool(
+    *,
+    tool_name: str,
+    arguments: dict,
+    base_url: str,
+    token: str,
+    registry: str,
+) -> None:
+    profile = load_profile(registry, base_url=base_url)
+    schema = fetch_schema(base_url=base_url)
+    tools = all_tools_for_profile(schema, profile)
+    tool = next((entry for entry in tools if entry["name"] == tool_name), None)
+    if tool is None:
+        raise SystemExit(f"Unknown tool: {tool_name}")
+
+    api = CrudApi(base_url=base_url, token=token)
+    path_args, body = split_arguments(
+        tool["path"], tool.get("operation", {}), arguments
+    )
+    rendered = render_path(tool["path"], path_args)
+    if "?" not in rendered and not rendered.endswith("/"):
+        rendered = f"{rendered}/"
+    response = api.request(tool["method"], rendered, json_body=body)
+    print(response.text)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="djcrud-client")
+    parser.add_argument("-mcp", action="store_true", help="Run stdio MCP server")
+    parser.add_argument(
+        "--registry",
+        default=None,
+        metavar="KEY",
+        help="Profile key (default: host default from GET /api/mcp/profiles/)",
+    )
+    parser.add_argument("--call", metavar="TOOL", help="Call one tool and exit")
+    parser.add_argument("--json", default="{}", help="Tool arguments as JSON object")
+    parser.add_argument("--user", help="Username for /api/login/")
+    parser.add_argument("--password", help="Password for /api/login/")
+    args = parser.parse_args(argv)
+
+    base_url = get_base_url()
+    registry = args.registry or get_registry_key(base_url=base_url)
+
+    if args.call:
+        token = resolve_token(
+            base_url=base_url,
+            username=args.user,
+            password=args.password,
+        )
+        arguments = json.loads(args.json)
+        call_tool(
+            tool_name=args.call,
+            arguments=arguments,
+            base_url=base_url,
+            token=token,
+            registry=registry,
+        )
+        return
+
+    token = resolve_token(
+        base_url=base_url,
+        username=args.user,
+        password=args.password,
+    )
+    create_mcp_server(
+        base_url=base_url,
+        token=token,
+        registry=registry,
+    ).run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

djcrud_client-0.3.1/src/djcrud_client/api.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+import httpx
+
+from .profile import McpProfile
+
+
+def login(*, base_url: str, username: str, password: str, timeout: float = 30.0) -> str:
+    url = f"{base_url.rstrip('/')}/api/login/"
+    with httpx.Client(timeout=timeout, follow_redirects=True) as client:
+        response = client.post(
+            url,
+            json={"username": username, "password": password},
+            headers={"Accept": "application/json"},
+        )
+        response.raise_for_status()
+        payload = response.json()
+    token = payload.get("token")
+    if not isinstance(token, str) or not token:
+        raise ValueError("login response missing token")
+    return token
+
+
+class CrudApi:
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        token: str,
+        timeout: float = 30.0,
+        extra_headers: dict[str, str] | Callable[[], dict[str, str]] | None = None,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.token = token
+        self.timeout = timeout
+        self._extra_headers = extra_headers
+
+    def _resolved_extra_headers(self) -> dict[str, str]:
+        if self._extra_headers is None:
+            return {}
+        if callable(self._extra_headers):
+            return dict(self._extra_headers())
+        return dict(self._extra_headers)
+
+    def _headers(self, accept_json: bool = True) -> dict[str, str]:
+        headers = {"Authorization": f"Bearer {self.token}"}
+        if accept_json:
+            headers["Accept"] = "application/json"
+        headers.update(self._resolved_extra_headers())
+        return headers
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: dict[str, Any] | None = None,
+        timeout: float | None = None,
+    ) -> httpx.Response:
+        url = f"{self.base_url}{path}"
+        effective_timeout = self.timeout if timeout is None else timeout
+        with httpx.Client(timeout=effective_timeout, follow_redirects=True) as client:
+            return client.request(
+                method.upper(),
+                url,
+                headers=self._headers(),
+                params=params,
+                json=json_body,
+            )
+
+    def fetch_schema(self) -> dict[str, Any]:
+        with httpx.Client(timeout=self.timeout) as client:
+            response = client.get(
+                f"{self.base_url}/api/schema/",
+                headers={"Accept": "application/json"},
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def fetch_json(self, path: str) -> Any:
+        with httpx.Client(timeout=self.timeout, follow_redirects=True) as client:
+            response = client.get(
+                f"{self.base_url}{path}",
+                headers={"Accept": "application/json"},
+            )
+            response.raise_for_status()
+            return response.json()
+
+
+def fetch_profile_catalog(*, base_url: str) -> tuple[list[str], str | None]:
+    payload = CrudApi(base_url=base_url, token="").fetch_json("/api/mcp/profiles/")
+    if isinstance(payload, dict):
+        keys = payload.get("profiles", payload.get("keys", []))
+        default = payload.get("default")
+    else:
+        keys = payload
+        default = None
+    profiles = [str(key).strip().lower() for key in keys]
+    default_key = (
+        str(default).strip().lower()
+        if isinstance(default, str) and default.strip()
+        else None
+    )
+    return profiles, default_key
+
+
+def list_profiles(*, base_url: str) -> list[str]:
+    profiles, _default = fetch_profile_catalog(base_url=base_url)
+    return profiles
+
+
+def resolve_registry_key(*, base_url: str, explicit: str | None = None) -> str:
+    if explicit and explicit.strip():
+        return explicit.strip().lower()
+
+    try:
+        profiles, default_key = fetch_profile_catalog(base_url=base_url)
+        if default_key:
+            return default_key
+        if len(profiles) == 1:
+            return profiles[0]
+    except Exception:
+        pass
+
+    return "default"
+
+
+def fetch_profile(*, base_url: str, key: str) -> McpProfile:
+    normalized = key.strip().lower()
+    payload = CrudApi(base_url=base_url, token="").fetch_json(
+        f"/api/mcp/profiles/{normalized}/"
+    )
+    return McpProfile.from_dict(payload)
+
+
+def fetch_viewsets(*, base_url: str) -> list[dict[str, str]]:
+    payload = CrudApi(base_url=base_url, token="").fetch_json("/api/mcp/viewsets/")
+    if isinstance(payload, dict):
+        entries = payload.get("viewsets", [])
+    else:
+        entries = payload
+    return [
+        {
+            "model": str(entry["model"]),
+            "prefix": str(entry["prefix"]),
+        }
+        for entry in entries
+    ]

djcrud_client-0.3.1/src/djcrud_client/config.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import os
+
+from .api import resolve_registry_key
+
+
+def _first_env(*keys: str) -> str:
+    for key in keys:
+        value = os.environ.get(key, "").strip()
+        if value:
+            return value
+    return ""
+
+
+def get_base_url() -> str:
+    value = _first_env("DJCRUD_BASE_URL", "DJMVC_BASE_URL", "TILDETTE_BASE_URL")
+    return (value or "http://127.0.0.1:8000").rstrip("/")
+
+
+def get_token() -> str:
+    return _first_env("DJCRUD_TOKEN", "DJMVC_TOKEN", "TILDETTE_TOKEN")
+
+
+def get_registry_key(*, base_url: str | None = None) -> str:
+    """Host default profile key from ``GET /api/mcp/profiles/`` (not an env var)."""
+    return resolve_registry_key(base_url=(base_url or get_base_url()).rstrip("/"))
+
+
+def get_profile_from_env():
+    from .server import load_profile
+
+    base_url = get_base_url()
+    return load_profile(get_registry_key(base_url=base_url), base_url=base_url)

djcrud_client-0.3.1/src/djcrud_client/profile.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class McpProfile:
+    """Wire-format MCP profile fetched from ``GET /api/mcp/profiles/{key}/``."""
+
+    key: str
+    server_name: str
+    instructions: str
+    info_tool_name: str
+    api_prefixes: tuple[str, ...]
+    meta: dict[str, Any]
+
+    def __init__(self) -> None:
+        self.key = ""
+        self.server_name = ""
+        self.instructions = ""
+        self.info_tool_name = ""
+        self.api_prefixes = ()
+        self.meta = {}
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> McpProfile:
+        profile = cls()
+        profile.key = str(payload["key"])
+        profile.server_name = str(payload["server_name"])
+        profile.instructions = str(payload["instructions"])
+        profile.info_tool_name = str(payload["info_tool_name"])
+        profile.api_prefixes = tuple(payload.get("api_prefixes", ()))
+        profile.meta = dict(payload.get("meta", {}))
+        return profile
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "key": self.key,
+            "server_name": self.server_name,
+            "instructions": self.instructions,
+            "info_tool_name": self.info_tool_name,
+            "api_prefixes": list(self.api_prefixes),
+            "meta": dict(self.meta),
+        }
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, McpProfile):
+            return NotImplemented
+        return self.to_dict() == other.to_dict()
+
+
+def profile_meta(profile: McpProfile) -> dict[str, Any]:
+    meta = dict(profile.meta)
+    if profile.api_prefixes:
+        meta.setdefault("api_prefixes", list(profile.api_prefixes))
+    return meta

djcrud_client-0.3.1/src/djcrud_client/schema.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .profile import McpProfile
+from .tools import build_tool_definition, infer_action
+
+
+def prefix_map_from_profile(profile: McpProfile) -> dict[str, str]:
+    """Build ``{model_name: api_prefix}`` from host-published ``api_prefixes``."""
+    result: dict[str, str] = {}
+    for prefix in profile.api_prefixes:
+        model_name = prefix.rstrip("/").split("/")[-1]
+        normalized = prefix if prefix.endswith("/") else prefix + "/"
+        result[model_name] = normalized
+    return result
+
+
+def build_tools_for_profile(
+    schema: dict[str, Any],
+    profile: McpProfile,
+) -> list[dict[str, Any]]:
+    return _build_tools_from_prefix_map(schema, prefix_map_from_profile(profile))
+
+
+def all_tools_for_profile(
+    schema: dict[str, Any],
+    profile: McpProfile,
+) -> list[dict[str, Any]]:
+    return build_tools_for_profile(schema, profile)
+
+
+def build_tools_from_schema(
+    schema: dict[str, Any],
+    *,
+    prefixes: dict[str, str],
+) -> list[dict[str, Any]]:
+    return _build_tools_from_prefix_map(schema, prefixes)
+
+
+def _build_tools_from_prefix_map(
+    schema: dict[str, Any],
+    prefixes: dict[str, str],
+) -> list[dict[str, Any]]:
+    by_name: dict[str, dict[str, Any]] = {}
+    paths: dict[str, Any] = {}
+    for path, operations in schema.get("paths", {}).items():
+        normalized = path.rstrip("/")
+        if any(
+            normalized == pfx.rstrip("/") or normalized.startswith(pfx.rstrip("/") + "/")
+            for pfx in prefixes.values()
+        ):
+            paths[path] = operations
+
+    for path, operations in paths.items():
+        for method, operation in operations.items():
+            if method.startswith("x-"):
+                continue
+            model_name = _model_for_path(path, prefixes)
+            if model_name is None:
+                continue
+            action = infer_action(
+                path=path,
+                method=method,
+                api_prefix=prefixes[model_name],
+                model_name=model_name,
+                operation=operation,
+            )
+            if not action:
+                continue
+            tool = build_tool_definition(
+                path=path,
+                method=method,
+                operation=operation,
+                model_name=model_name,
+                action=action,
+            )
+            existing = by_name.get(tool["name"])
+            if existing is None or method == "patch":
+                by_name[tool["name"]] = tool
+    return list(by_name.values())
+
+
+def _model_for_path(path: str, prefixes: dict[str, str]) -> str | None:
+    normalized = path.rstrip("/") + "/"
+    matches = [
+        model_name
+        for model_name, prefix in prefixes.items()
+        if normalized.startswith(prefix.rstrip("/") + "/") or normalized == prefix
+    ]
+    if not matches:
+        return None
+    return min(matches, key=len)

djcrud_client-0.3.1/src/djcrud_client/server.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from .api import CrudApi, fetch_profile
+from .config import get_base_url, get_registry_key, get_token
+from .profile import McpProfile, profile_meta
+from .schema import build_tools_for_profile
+from .tools import render_path, split_arguments
+
+
+def fetch_schema(*, base_url: str) -> dict[str, Any]:
+    return CrudApi(base_url=base_url, token="").fetch_schema()
+
+
+def load_profile(key: str, *, base_url: str) -> McpProfile:
+    return fetch_profile(base_url=base_url, key=key)
+
+
+def create_mcp_server(
+    *,
+    base_url: str | None = None,
+    token: str | None = None,
+    profile: McpProfile | str | None = None,
+    registry: str | None = None,
+    extra_headers: dict[str, str] | None = None,
+) -> FastMCP:
+    base_url = (base_url or get_base_url()).rstrip("/")
+    registry_key = (
+        profile
+        if isinstance(profile, str)
+        else (registry or get_registry_key(base_url=base_url))
+    )
+    if isinstance(profile, str) or profile is None:
+        profile = load_profile(str(registry_key), base_url=base_url)
+    token = token if token is not None else get_token()
+    schema = fetch_schema(base_url=base_url)
+    api = CrudApi(base_url=base_url, token=token, extra_headers=extra_headers)
+    mcp = FastMCP(profile.server_name, instructions=profile.instructions)
+
+    def registry_info() -> str:
+        return json.dumps(profile_meta(profile), indent=2)
+
+    registry_info.__name__ = profile.info_tool_name
+    mcp.add_tool(
+        registry_info,
+        name=profile.info_tool_name,
+        description=profile.instructions,
+    )
+
+    for tool in build_tools_for_profile(schema, profile):
+        _register_tool(mcp, api, tool)
+
+    return mcp
+
+
+def _register_tool(mcp: FastMCP, api: CrudApi, tool: dict[str, Any]) -> None:
+    path = tool["path"]
+    method = tool["method"]
+    operation = tool.get("operation", {})
+
+    def handler(**arguments: Any) -> str:
+        if set(arguments.keys()) == {"arguments"} and isinstance(
+            arguments["arguments"], dict
+        ):
+            arguments = arguments["arguments"]
+        path_args, body = split_arguments(path, operation, arguments)
+        rendered = render_path(path, path_args)
+        if "?" not in rendered and not rendered.endswith("/"):
+            rendered = f"{rendered}/"
+        response = api.request(method, rendered, json_body=body)
+        try:
+            payload: Any = response.json()
+        except Exception:
+            payload = {"status_code": response.status_code, "text": response.text}
+        return json.dumps(payload, indent=2)
+
+    handler.__name__ = tool["name"]
+    handler.__doc__ = tool["description"]
+    mcp.add_tool(
+        handler,
+        name=tool["name"],
+        description=tool["description"],
+    )
+
+
+def run_stdio(*, registry: str | None = None) -> None:
+    create_mcp_server(registry=registry).run(transport="stdio")

djcrud_client-0.3.1/src/djcrud_client/tools.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import Any
+
+STANDARD_ACTIONS = (
+    "partial_update",
+    "destroy",
+    "retrieve",
+    "update",
+    "create",
+    "list",
+)
+
+METHOD_DEFAULT_ACTION = {
+    "get": "list",
+    "post": "create",
+    "put": "update",
+    "patch": "partial_update",
+    "delete": "destroy",
+}
+
+
+def tool_name(model_name: str, action: str) -> str:
+    return f"{model_name.lower()}_{action}"
+
+
+_METHOD_SUFFIXES = (
+    "_partial_update",
+    "_destroy",
+    "_retrieve",
+    "_update",
+    "_create",
+    "_list",
+)
+
+
+def parse_operation_id(operation_id: str, *, model_name: str) -> str | None:
+    prefix = f"{model_name}_"
+    if not operation_id.startswith(prefix):
+        return None
+    suffix = operation_id[len(prefix) :]
+    if suffix in STANDARD_ACTIONS:
+        return suffix
+    for method_suffix in _METHOD_SUFFIXES:
+        if suffix.endswith(method_suffix):
+            action = suffix[: -len(method_suffix)]
+            if action:
+                return action
+    return suffix
+
+
+def infer_action(
+    *,
+    path: str,
+    method: str,
+    api_prefix: str,
+    model_name: str,
+    operation: dict[str, Any],
+) -> str | None:
+    operation_id = operation.get("operationId") or ""
+    parsed = parse_operation_id(operation_id, model_name=model_name)
+    if parsed:
+        return parsed
+
+    normalized_path = path.rstrip("/") + "/"
+    normalized_prefix = api_prefix.rstrip("/") + "/"
+    if not normalized_path.startswith(normalized_prefix):
+        return None
+
+    relative = normalized_path[len(normalized_prefix) :]
+    method = method.lower()
+
+    if not relative:
+        return METHOD_DEFAULT_ACTION.get(method)
+
+    segments = [segment for segment in relative.split("/") if segment]
+    if not segments:
+        return METHOD_DEFAULT_ACTION.get(method)
+
+    if segments[0].startswith("{"):
+        if len(segments) == 1:
+            return METHOD_DEFAULT_ACTION.get(method)
+        return segments[1].rstrip("/")
+
+    return segments[0].rstrip("/")
+
+
+def render_path(path: str, arguments: dict[str, Any]) -> str:
+    rendered = path
+    for key, value in arguments.items():
+        rendered = rendered.replace("{" + key + "}", str(value))
+    return rendered
+
+
+def _path_parameters(operation: dict[str, Any]) -> dict[str, Any]:
+    properties: dict[str, Any] = {}
+    for parameter in operation.get("parameters", []):
+        if parameter.get("in") == "path":
+            schema = parameter.get("schema", {})
+            properties[parameter["name"]] = {
+                "type": schema.get("type", "string"),
+            }
+    return properties
+
+
+def _body_properties(operation: dict[str, Any]) -> dict[str, Any]:
+    for parameter in operation.get("parameters", []):
+        if parameter.get("in") == "body":
+            schema = parameter.get("schema", {})
+            return schema.get("properties", {})
+
+    request_body = operation.get("requestBody") or {}
+    for media in (request_body.get("content") or {}).values():
+        schema = media.get("schema") or {}
+        return schema.get("properties", {})
+    return {}
+
+
+def _body_required(operation: dict[str, Any]) -> list[str]:
+    for parameter in operation.get("parameters", []):
+        if parameter.get("in") == "body":
+            schema = parameter.get("schema", {})
+            return list(schema.get("required", []))
+
+    request_body = operation.get("requestBody") or {}
+    for media in (request_body.get("content") or {}).values():
+        schema = media.get("schema") or {}
+        return list(schema.get("required", []))
+    return []
+
+
+def split_arguments(
+    path: str,
+    operation: dict[str, Any],
+    arguments: dict[str, Any],
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
+    path_args = {
+        key: value for key, value in arguments.items() if "{" + key + "}" in path
+    }
+    body_keys = set(_body_properties(operation))
+    body = {key: value for key, value in arguments.items() if key in body_keys}
+    return path_args, body or None
+
+
+def build_tool_definition(
+    *,
+    path: str,
+    method: str,
+    operation: dict[str, Any],
+    model_name: str,
+    action: str,
+) -> dict[str, Any]:
+    properties: dict[str, Any] = {}
+    properties.update(_path_parameters(operation))
+    properties.update(_body_properties(operation))
+    required = [name for name in properties if "{" + name + "}" in path]
+    required.extend(
+        name for name in _body_required(operation) if name not in required
+    )
+    return {
+        "name": tool_name(model_name, action),
+        "description": operation.get("summary") or f"{method.upper()} {path}",
+        "method": method.lower(),
+        "path": path,
+        "operation": operation,
+        "input_schema": {
+            "type": "object",
+            "properties": properties,
+            "required": required,
+        },
+    }

djcrud_client-0.3.1/src/djcrud_client.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: djcrud-client
+Version: 0.3.1
+Summary: Stdio MCP bridge for djcrud JSON APIs (no Django required)
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp<2,>=1.0
+Requires-Dist: httpx>=0.27
+
+# djcrud-client
+
+Stdio MCP bridge for [djcrud](https://github.com/yourlabs/djcrud) JSON APIs. No Django required in the subprocess — FastMCP runs here, not on the Django host.
+
+## Install
+
+```bash
+pip install djcrud-client
+djcrud-client -mcp
+```
+
+## Host setup
+
+Declare `McpProfile` classes in your app's `djcrud.py` and register them on `djcrud_mcp.site` (see `djcrud_example/mcp_example/djcrud.py` in the djcrud repo).
+
+Add `djcrud_mcp` to `INSTALLED_APPS` and include `djcrud_drf.site` URLs on the host. Register one `McpProfile` in your app's `djcrud.py` (see `mcp_example/djcrud.py`). Run `djcrud-client -mcp` with `DJCRUD_TOKEN` set.

djcrud_client-0.3.1/src/djcrud_client.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+src/djcrud_client/__init__.py
+src/djcrud_client/__main__.py
+src/djcrud_client/api.py
+src/djcrud_client/config.py
+src/djcrud_client/profile.py
+src/djcrud_client/schema.py
+src/djcrud_client/server.py
+src/djcrud_client/tools.py
+src/djcrud_client.egg-info/PKG-INFO
+src/djcrud_client.egg-info/SOURCES.txt
+src/djcrud_client.egg-info/dependency_links.txt
+src/djcrud_client.egg-info/entry_points.txt
+src/djcrud_client.egg-info/requires.txt
+src/djcrud_client.egg-info/scm_file_list.json
+src/djcrud_client.egg-info/scm_version.json
+src/djcrud_client.egg-info/top_level.txt
+tests/test_config.py
+tests/test_resolve_registry.py
+tests/test_standalone.py

djcrud_client-0.3.1/src/djcrud_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

djcrud_client-0.3.1/src/djcrud_client.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+djcrud-client = djcrud_client.__main__:main

djcrud_client-0.3.1/src/djcrud_client.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp<2,>=1.0
+httpx>=0.27

djcrud_client-0.3.1/src/djcrud_client.egg-info/scm_file_list.json

@@ -0,0 +1,17 @@
+{
+  "files": [
+    "README.md",
+    "pyproject.toml",
+    "tests/test_config.py",
+    "tests/test_resolve_registry.py",
+    "tests/test_standalone.py",
+    "src/djcrud_client/server.py",
+    "src/djcrud_client/tools.py",
+    "src/djcrud_client/config.py",
+    "src/djcrud_client/__init__.py",
+    "src/djcrud_client/profile.py",
+    "src/djcrud_client/schema.py",
+    "src/djcrud_client/__main__.py",
+    "src/djcrud_client/api.py"
+  ]
+}

djcrud_client-0.3.1/src/djcrud_client.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.3.1",
+  "distance": 0,
+  "node": "g3d1f991046136ee7e0438776cda491804f21bcfb",
+  "dirty": false,
+  "branch": "master",
+  "node_date": "2026-07-03"
+}

djcrud_client-0.3.1/src/djcrud_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+djcrud_client

djcrud_client-0.3.1/tests/test_config.py

@@ -0,0 +1,17 @@
+"""Tests for djcrud_client.config."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from djcrud_client.config import get_registry_key
+
+
+def test_get_registry_key_ignores_registry_env_var(monkeypatch):
+    monkeypatch.setenv("DJCRUD_MCP_REGISTRY", "ignored")
+    monkeypatch.setenv("TILDETTE_MCP_REGISTRY", "also-ignored")
+    with patch(
+        "djcrud_client.api.fetch_profile_catalog",
+        return_value=(["tasks", "mcp"], "tasks"),
+    ):
+        assert get_registry_key(base_url="http://example.test") == "tasks"

djcrud_client-0.3.1/tests/test_resolve_registry.py

@@ -0,0 +1,42 @@
+"""Tests for host-published default MCP registry resolution."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from djcrud_client.api import resolve_registry_key
+
+
+def test_resolve_registry_key_prefers_explicit():
+    key = resolve_registry_key(
+        base_url="http://example.test",
+        explicit="custom",
+    )
+    assert key == "custom"
+
+
+def test_resolve_registry_key_uses_host_default():
+    with patch(
+        "djcrud_client.api.fetch_profile_catalog",
+        return_value=(["tasks", "mcp"], "tasks"),
+    ):
+        key = resolve_registry_key(base_url="http://example.test")
+    assert key == "tasks"
+
+
+def test_resolve_registry_key_uses_single_profile():
+    with patch(
+        "djcrud_client.api.fetch_profile_catalog",
+        return_value=(["articles"], None),
+    ):
+        key = resolve_registry_key(base_url="http://example.test")
+    assert key == "articles"
+
+
+def test_resolve_registry_key_falls_back_to_default():
+    with patch(
+        "djcrud_client.api.fetch_profile_catalog",
+        side_effect=OSError("offline"),
+    ):
+        key = resolve_registry_key(base_url="http://example.test")
+    assert key == "default"

djcrud_client-0.3.1/tests/test_standalone.py

@@ -0,0 +1,113 @@
+"""Tests for djcrud-client without Django."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from unittest.mock import patch
+
+import pytest
+
+SAMPLE_SCHEMA = {
+    "paths": {
+        "/api/product/": {
+            "get": {
+                "operationId": "product_list",
+                "summary": "List products",
+                "parameters": [],
+            },
+            "post": {
+                "operationId": "product_create",
+                "summary": "Create product",
+                "requestBody": {
+                    "content": {
+                        "application/json": {
+                            "schema": {
+                                "type": "object",
+                                "properties": {"name": {"type": "string"}},
+                                "required": ["name"],
+                            }
+                        }
+                    }
+                },
+            },
+        },
+    }
+}
+
+
+def test_imports_no_django():
+    script = """
+import sys
+for name in list(sys.modules):
+    if name.startswith("django"):
+        del sys.modules[name]
+import djcrud_client.server
+assert not [name for name in sys.modules if name.startswith("django")]
+"""
+    subprocess.run([sys.executable, "-c", script], check=True)
+
+
+def test_build_tools_from_api_prefixes():
+    from djcrud_client import McpProfile
+    from djcrud_client.schema import build_tools_for_profile
+
+    profile = McpProfile.from_dict(
+        {
+            "key": "items",
+            "server_name": "test",
+            "instructions": "test",
+            "info_tool_name": "info",
+            "api_prefixes": ["/api/product/"],
+            "meta": {},
+        }
+    )
+    tools = build_tools_for_profile(SAMPLE_SCHEMA, profile)
+    names = {tool["name"] for tool in tools}
+    assert names == {"product_list", "product_create"}
+
+
+def test_create_mcp_server_with_api_prefixes():
+    from djcrud_client import McpProfile
+    from djcrud_client.server import create_mcp_server
+
+    profile = McpProfile.from_dict(
+        {
+            "key": "custom",
+            "server_name": "test-custom",
+            "instructions": "Custom tools.",
+            "info_tool_name": "custom_registry_info",
+            "api_prefixes": ["/api/product/"],
+            "meta": {},
+        }
+    )
+
+    with patch("djcrud_client.server.fetch_schema", return_value=SAMPLE_SCHEMA):
+        mcp = create_mcp_server(
+            base_url="http://testserver",
+            token="tok",
+            profile=profile,
+        )
+
+    tool_names = set(mcp._tool_manager._tools.keys())
+    assert "product_list" in tool_names
+    assert "custom_registry_info" in tool_names
+
+
+def test_profile_meta_uses_api_prefixes():
+    from djcrud_client import McpProfile
+    from djcrud_client.profile import profile_meta
+
+    profile = McpProfile.from_dict(
+        {
+            "key": "items",
+            "server_name": "test",
+            "instructions": "test",
+            "info_tool_name": "info",
+            "api_prefixes": ["/api/product/"],
+            "meta": {},
+        }
+    )
+    meta = profile_meta(profile)
+    assert meta["api_prefixes"] == ["/api/product/"]
+    assert "viewsets" not in meta