code-analysis-client 1.0.0__py3-none-any.whl

code_analysis_client/__init__.py

@@ -0,0 +1,54 @@
+"""
+Public async client for code-analysis-server (JSON-RPC via mcp-proxy-adapter).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from code_analysis_client.client import CodeAnalysisAsyncClient
+from code_analysis_client.commands_proxy import ValidatedCommandsProxy
+from code_analysis_client.config import (
+    adapter_settings_from_server_config,
+    adapter_settings_to_jsonrpc_kwargs,
+    load_server_config,
+)
+from code_analysis_client.exceptions import ClientValidationError
+from code_analysis_client.server_schema import (
+    fetch_command_schema_from_server,
+    parse_schema_from_help_payload,
+)
+from code_analysis_client.validation import (
+    prepare_params_for_schema,
+    validate_params_against_schema,
+)
+
+__all__ = [
+    "ClientValidationError",
+    "CodeAnalysisAsyncClient",
+    "ValidatedCommandsProxy",
+    "adapter_settings_from_server_config",
+    "adapter_settings_to_jsonrpc_kwargs",
+    "fetch_command_schema_from_server",
+    "load_server_config",
+    "parse_schema_from_help_payload",
+    "prepare_params_for_schema",
+    "validate_params_against_schema",
+]
+
+def _read_package_version() -> str:
+    vf = Path(__file__).resolve().parent / "version.txt"
+    if vf.is_file():
+        return vf.read_text(encoding="utf-8").strip()
+    try:
+        import importlib.metadata as _imd
+
+        return _imd.version("code-analysis-client")
+    except Exception:
+        return "0.0.0"
+
+
+__version__ = _read_package_version()

code_analysis_client/client.py

@@ -0,0 +1,225 @@
+"""
+Async façade over mcp-proxy-adapter JsonRpcClient for code-analysis-server.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Mapping, Optional
+
+try:
+    from mcp_proxy_adapter.client.jsonrpc_client.client import JsonRpcClient
+except Exception:  # pragma: no cover - compatibility with older layouts
+    from mcp_proxy_adapter.client.jsonrpc_client import JsonRpcClient
+
+from code_analysis_client.commands_proxy import ValidatedCommandsProxy
+from code_analysis_client.config import (
+    adapter_settings_from_server_config,
+    adapter_settings_to_jsonrpc_kwargs,
+    load_server_config,
+)
+from code_analysis_client.server_schema import fetch_command_schema_from_server
+from code_analysis_client.validation import (
+    prepare_params_for_schema,
+    validate_params_against_schema,
+)
+
+
+class CodeAnalysisAsyncClient:
+    """Async client: domain commands via :meth:`call` / :meth:`call_unified`; full adapter API on :attr:`rpc`."""
+
+    __slots__ = ("_rpc", "_command_schema_cache", "_commands_proxy")
+
+    def __init__(self, **jsonrpc_kwargs: Any) -> None:
+        """Same keyword arguments as ``JsonRpcClient`` (``protocol``, ``host``, ``port``, ``cert``, …)."""
+        self._rpc = JsonRpcClient(**jsonrpc_kwargs)
+        self._command_schema_cache: Dict[str, Dict[str, Any]] = {}
+        self._commands_proxy: Optional[ValidatedCommandsProxy] = None
+
+    @classmethod
+    def from_jsonrpc_kwargs(cls, **kwargs: Any) -> CodeAnalysisAsyncClient:
+        """Alias for ``CodeAnalysisAsyncClient(**kwargs)``."""
+        return cls(**kwargs)
+
+    @classmethod
+    def from_adapter_settings(
+        cls,
+        settings: Mapping[str, Any],
+        *,
+        timeout: float | None = 60.0,
+        check_hostname: bool = False,
+        token_header: str | None = None,
+        token: str | None = None,
+    ) -> CodeAnalysisAsyncClient:
+        """Build from a dict like ``PipelineConfig.generate_adapter_client_settings()``."""
+        kwargs = adapter_settings_to_jsonrpc_kwargs(
+            settings,
+            timeout=timeout,
+            check_hostname=check_hostname,
+            token_header=token_header,
+            token=token,
+        )
+        return cls(**kwargs)
+
+    @classmethod
+    def from_server_config(
+        cls,
+        config: Mapping[str, Any],
+        *,
+        timeout: float | None = 60.0,
+        check_hostname: bool = False,
+        token_header: str | None = None,
+        token: str | None = None,
+    ) -> CodeAnalysisAsyncClient:
+        """Derive connection settings from a code-analysis server config object."""
+        settings = adapter_settings_from_server_config(config)
+        return cls.from_adapter_settings(
+            settings,
+            timeout=timeout,
+            check_hostname=check_hostname,
+            token_header=token_header,
+            token=token,
+        )
+
+    @classmethod
+    def from_server_config_path(
+        cls,
+        path: str | Path,
+        *,
+        timeout: float | None = 60.0,
+        check_hostname: bool = False,
+        token_header: str | None = None,
+        token: str | None = None,
+    ) -> CodeAnalysisAsyncClient:
+        """Load ``config.json`` and connect."""
+        return cls.from_server_config(
+            load_server_config(path),
+            timeout=timeout,
+            check_hostname=check_hostname,
+            token_header=token_header,
+            token=token,
+        )
+
+    @property
+    def rpc(self) -> JsonRpcClient:
+        """Underlying mcp-proxy-adapter client (queue, transfer, ``help``, ``execute_command``, …)."""
+        return self._rpc
+
+    @property
+    def commands(self) -> ValidatedCommandsProxy:
+        """Dynamic validated wrappers: schema is loaded from the server via ``help`` (cached)."""
+        if self._commands_proxy is None:
+            self._commands_proxy = ValidatedCommandsProxy(self)
+        return self._commands_proxy
+
+    def clear_command_schema_cache(self) -> None:
+        """Drop cached command schemas (after ``reload`` or when server definitions change)."""
+        self._command_schema_cache.clear()
+
+    async def get_command_schema(
+        self, command: str, *, refresh: bool = False
+    ) -> Dict[str, Any]:
+        """Fetch input JSON schema for ``command`` using server ``help`` (with in-memory cache)."""
+        if not refresh and command in self._command_schema_cache:
+            return self._command_schema_cache[command]
+        schema = await fetch_command_schema_from_server(self._rpc, command)
+        self._command_schema_cache[command] = schema
+        return schema
+
+    async def call_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        refresh_schema: bool = False,
+    ) -> Dict[str, Any]:
+        """``help`` → schema on server, shallow local validation, then ``execute_command``."""
+        schema = await self.get_command_schema(command, refresh=refresh_schema)
+        merged = dict(params or {})
+        prepared = prepare_params_for_schema(merged, schema)
+        validate_params_against_schema(prepared, schema, command_name=command)
+        return await self._rpc.execute_command(
+            command,
+            prepared,
+            use_cmd_endpoint=use_cmd_endpoint,
+        )
+
+    async def call_unified_validated(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        refresh_schema: bool = False,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: bool = True,
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[Callable[[Dict[str, Any]], Any]] = None,
+    ) -> Dict[str, Any]:
+        """Same as :meth:`call_validated` but uses ``execute_command_unified``."""
+        schema = await self.get_command_schema(command, refresh=refresh_schema)
+        merged = dict(params or {})
+        prepared = prepare_params_for_schema(merged, schema)
+        validate_params_against_schema(prepared, schema, command_name=command)
+        return await self._rpc.execute_command_unified(
+            command,
+            prepared,
+            use_cmd_endpoint=use_cmd_endpoint,
+            expect_queue=expect_queue,
+            auto_poll=auto_poll,
+            poll_interval=poll_interval,
+            timeout=timeout,
+            status_hook=status_hook,
+        )
+
+    async def call(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+    ) -> Dict[str, Any]:
+        """Run any registered server command (sync completion)."""
+        return await self._rpc.execute_command(
+            command,
+            params or {},
+            use_cmd_endpoint=use_cmd_endpoint,
+        )
+
+    async def call_unified(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        *,
+        use_cmd_endpoint: bool = False,
+        expect_queue: Optional[bool] = None,
+        auto_poll: bool = True,
+        poll_interval: float = 1.0,
+        timeout: Optional[float] = None,
+        status_hook: Optional[Callable[[Dict[str, Any]], Any]] = None,
+    ) -> Dict[str, Any]:
+        """Run a command with optional queue detection and polling (adapter unified path)."""
+        return await self._rpc.execute_command_unified(
+            command,
+            params or {},
+            use_cmd_endpoint=use_cmd_endpoint,
+            expect_queue=expect_queue,
+            auto_poll=auto_poll,
+            poll_interval=poll_interval,
+            timeout=timeout,
+            status_hook=status_hook,
+        )
+
+    async def close(self) -> None:
+        await self._rpc.close()
+
+    async def __aenter__(self) -> CodeAnalysisAsyncClient:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        await self.close()

code_analysis_client/commands_proxy.py

@@ -0,0 +1,60 @@
+"""
+Dynamic command wrappers: schema from server ``help``, then local shallow validation.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional, cast
+
+if TYPE_CHECKING:
+    from code_analysis_client.client import CodeAnalysisAsyncClient
+
+
+class ValidatedCommandsProxy:
+    """``client.commands.<name>(**params)`` — fetch schema via ``help``, validate, ``execute_command``."""
+
+    __slots__ = ("_client",)
+
+    def __init__(self, client: CodeAnalysisAsyncClient) -> None:
+        object.__setattr__(self, "_client", client)
+
+    def clear_schema_cache(self) -> None:
+        """Forget cached schemas (e.g. after server ``reload``)."""
+        self._client.clear_command_schema_cache()
+
+    async def fetch_schema(
+        self, command: str, *, refresh: bool = False
+    ) -> Dict[str, Any]:
+        """Return input JSON schema for ``command`` (from server ``help``)."""
+        return cast(
+            Dict[str, Any],
+            await self._client.get_command_schema(command, refresh=refresh),
+        )
+
+    async def invoke(
+        self,
+        command: str,
+        params: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Dict[str, Any]:
+        """Merge ``params`` and ``kwargs``, validate against server schema, execute."""
+        merged: Dict[str, Any] = dict(params or {})
+        if kwargs:
+            merged.update(kwargs)
+        return cast(Dict[str, Any], await self._client.call_validated(command, merged))
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            raise AttributeError(name)
+
+        async def _bound(**kw: Any) -> Dict[str, Any]:
+            return cast(Dict[str, Any], await self._client.call_validated(name, kw))
+
+        _bound.__name__ = name
+        _bound.__doc__ = (
+            f"Validated call for command {name!r} (schema from server help)."
+        )
+        return _bound

code_analysis_client/config.py

@@ -0,0 +1,126 @@
+"""
+Map server / adapter-style settings dicts to JsonRpcClient constructor kwargs.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+
+def _expand_path(value: Any) -> str | None:
+    if value is None or value == "":
+        return None
+    return str(Path(str(value)).expanduser().resolve())
+
+
+def _ssl_paths_from_section(ssl_section: Any) -> dict[str, str]:
+    if not isinstance(ssl_section, dict):
+        return {}
+    out: dict[str, str] = {}
+    for key in ("cert", "key", "ca", "cert_path", "key_path", "ca_path"):
+        raw = ssl_section.get(key)
+        expanded = _expand_path(raw) if raw else None
+        if expanded:
+            out[key] = expanded
+    # Normalize aliases to cert/key/ca for downstream comparison / JsonRpcClient
+    if "cert" not in out and out.get("cert_path"):
+        out["cert"] = out["cert_path"]
+    if "key" not in out and out.get("key_path"):
+        out["key"] = out["key_path"]
+    if "ca" not in out and out.get("ca_path"):
+        out["ca"] = out["ca_path"]
+    return out
+
+
+def _network_from_server_config(config: Mapping[str, Any]) -> dict[str, Any]:
+    server = config.get("server", {})
+    if not isinstance(server, dict):
+        server = {}
+    host = server.get("host", "127.0.0.1")
+    if host in ("0.0.0.0", "::", "[::]"):
+        host = "127.0.0.1"
+    return {
+        "host": host,
+        "port": int(server.get("port", 15001)),
+        "protocol": server.get("protocol", "http"),
+    }
+
+
+def _client_mtls_paths_from_server_config(config: Mapping[str, Any]) -> dict[str, str]:
+    """Prefer client.ssl; fall back to server.ssl (same rules as pipeline)."""
+    client_section = config.get("client", {})
+    if isinstance(client_section, dict):
+        ssl_section = client_section.get("ssl", {})
+        if isinstance(ssl_section, dict) and any(
+            ssl_section.get(k) for k in ("cert", "cert_path", "key", "key_path")
+        ):
+            return _ssl_paths_from_section(ssl_section)
+    server = config.get("server", {})
+    if not isinstance(server, dict):
+        return {}
+    return _ssl_paths_from_section(server.get("ssl", {}))
+
+
+def adapter_settings_from_server_config(config: Mapping[str, Any]) -> dict[str, Any]:
+    """Build adapter-style settings from a code-analysis server config dict."""
+    settings = dict(_network_from_server_config(config))
+    proto = str(settings.get("protocol", "")).lower()
+    if proto == "mtls":
+        settings["ssl"] = _client_mtls_paths_from_server_config(config)
+    elif proto == "https":
+        ssl_paths = _client_mtls_paths_from_server_config(config)
+        if ssl_paths.get("cert") and ssl_paths.get("key"):
+            settings["ssl"] = ssl_paths
+    return settings
+
+
+def adapter_settings_to_jsonrpc_kwargs(
+    settings: Mapping[str, Any],
+    *,
+    timeout: float | None = 60.0,
+    check_hostname: bool = False,
+    token_header: str | None = None,
+    token: str | None = None,
+) -> dict[str, Any]:
+    """Turn adapter-style settings into keyword args for JsonRpcClient."""
+    ssl_section = settings.get("ssl")
+    cert = key = ca = None
+    if isinstance(ssl_section, dict):
+        cert = ssl_section.get("cert") or ssl_section.get("cert_path")
+        key = ssl_section.get("key") or ssl_section.get("key_path")
+        ca = ssl_section.get("ca") or ssl_section.get("ca_path")
+        cert = _expand_path(cert) if cert else None
+        key = _expand_path(key) if key else None
+        ca = _expand_path(ca) if ca else None
+
+    th = token_header if token_header is not None else settings.get("token_header")
+    tok = token if token is not None else settings.get("token")
+
+    return {
+        "protocol": str(settings.get("protocol", "http")),
+        "host": str(settings.get("host", "127.0.0.1")),
+        "port": int(settings.get("port", 8080)),
+        "token_header": str(th) if th else None,
+        "token": str(tok) if tok else None,
+        "cert": cert,
+        "key": key,
+        "ca": ca,
+        "check_hostname": check_hostname,
+        "timeout": timeout,
+    }
+
+
+def load_server_config(path: str | Path) -> dict[str, Any]:
+    """Load server config.json into a dict."""
+    p = Path(path).expanduser()
+    with p.open("r", encoding="utf-8") as f:
+        data: Any = json.load(f)
+    if not isinstance(data, dict):
+        raise ValueError("Server config must be a JSON object")
+    # py3.10: return plain dict for mutability
+    return dict(data)

code_analysis_client/exceptions.py

@@ -0,0 +1,20 @@
+"""Client-side errors (no dependency on code_analysis server package)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+
+class ClientValidationError(ValueError):
+    """Parameters do not match the command JSON schema (from server ``help``)."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        field: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.field = field
+        self.details = details or {}

code_analysis_client/server_schema.py

@@ -0,0 +1,57 @@
+"""
+Load per-command JSON schema from the running server via ``help`` (cmdname).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from code_analysis_client.exceptions import ClientValidationError
+
+
+def parse_schema_from_help_payload(
+    payload: Dict[str, Any], *, command_name: str
+) -> Dict[str, Any]:
+    """Extract ``get_schema()``-style dict from ``help`` JSON-RPC result."""
+    if not payload.get("success"):
+        raise ClientValidationError(
+            f"{command_name}: help returned success=false: {payload!r}",
+            field="help",
+            details={"payload": payload},
+        )
+    data = payload.get("data")
+    if not isinstance(data, dict):
+        raise ClientValidationError(
+            f"{command_name}: help response missing object 'data'",
+            field="help",
+        )
+    if data.get("error") and "schema" not in data:
+        raise ClientValidationError(
+            f"{command_name}: {data.get('error')}",
+            field="help",
+            details={"note": data.get("note"), "example": data.get("example")},
+        )
+    schema = data.get("schema")
+    if not isinstance(schema, dict):
+        raise ClientValidationError(
+            f"{command_name}: help response has no 'schema' object",
+            field="help",
+        )
+    return schema
+
+
+async def fetch_command_schema_from_server(
+    rpc: Any,
+    command_name: str,
+) -> Dict[str, Any]:
+    """Call server ``help`` with ``cmdname`` and return that command's input schema."""
+    raw = await rpc.help(command_name)
+    if not isinstance(raw, dict):
+        raise ClientValidationError(
+            f"{command_name}: help returned non-dict: {type(raw).__name__}",
+            field="help",
+        )
+    return parse_schema_from_help_payload(raw, command_name=command_name)

code_analysis_client/validation.py

@@ -0,0 +1,101 @@
+"""
+Shallow JSON-schema validation aligned with BaseMCPCommand.validate_params_against_schema.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from code_analysis_client.exceptions import ClientValidationError
+
+
+def prepare_params_for_schema(
+    params: Dict[str, Any], schema: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Drop unknown keys when ``additionalProperties`` is false (same as server base)."""
+    props = schema.get("properties") or {}
+    if not schema.get("additionalProperties", True):
+        return {k: v for k, v in params.items() if k in props}
+    return dict(params)
+
+
+def validate_params_against_schema(
+    params: Dict[str, Any],
+    schema: Dict[str, Any],
+    command_name: str = "command",
+) -> None:
+    """Validate params against a command ``get_schema()``-style object (subset)."""
+    if not isinstance(params, dict):
+        raise ClientValidationError(
+            f"{command_name}: params must be a dict, got {type(params).__name__}",
+            field="params",
+        )
+    props = schema.get("properties") or {}
+    additional_ok = schema.get("additionalProperties", True)
+    required_set = set(schema.get("required") or [])
+    for key, value in params.items():
+        if key not in props:
+            if not additional_ok:
+                raise ClientValidationError(
+                    f"{command_name}: unknown parameter {key!r}. "
+                    "Only schema-defined properties are allowed.",
+                    field=key,
+                    details={"allowed": list(props.keys())},
+                )
+            continue
+        if value is None:
+            continue
+        prop = props[key]
+        expected_type = prop.get("type")
+        if expected_type == "string":
+            if not isinstance(value, str):
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be string, got {type(value).__name__}",
+                    field=key,
+                )
+        elif expected_type == "integer":
+            if not isinstance(value, int) or isinstance(value, bool):
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be integer, got {type(value).__name__}",
+                    field=key,
+                )
+        elif expected_type == "number":
+            if not isinstance(value, (int, float)) or isinstance(value, bool):
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be number, got {type(value).__name__}",
+                    field=key,
+                )
+        elif expected_type == "boolean":
+            if not isinstance(value, bool):
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be boolean, got {type(value).__name__}",
+                    field=key,
+                )
+        elif expected_type == "array":
+            if not isinstance(value, list):
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be array, got {type(value).__name__}",
+                    field=key,
+                )
+        elif expected_type == "object":
+            if not isinstance(value, dict):
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be object, got {type(value).__name__}",
+                    field=key,
+                )
+        if "enum" in prop and value is not None:
+            if value not in prop["enum"]:
+                raise ClientValidationError(
+                    f"{command_name}: parameter {key!r} must be one of {prop['enum']!r}, got {value!r}",
+                    field=key,
+                    details={"enum": prop["enum"]},
+                )
+    for key in required_set:
+        if key not in params or params[key] is None:
+            raise ClientValidationError(
+                f"{command_name}: required parameter {key!r} is missing",
+                field=key,
+            )

code_analysis_client/version.txt

@@ -0,0 +1 @@
+1.0.0

code_analysis_client-1.0.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: code-analysis-client
+Version: 1.0.0
+Summary: Async JSON-RPC client for the code-analysis MCP server (mcp-proxy-adapter JsonRpcClient)
+Author-email: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp-proxy-adapter>=8.10.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
+
+# code-analysis-client
+
+Async Python client for the **code-analysis** server. It wraps `mcp-proxy-adapter`’s `JsonRpcClient`, so you get the adapter’s built-in methods (queue, transfer, `help`, `health`, …) plus thin helpers to run any registered server command.
+
+## Install
+
+```bash
+pip install code-analysis-client
+```
+
+## Usage
+
+```python
+import asyncio
+from code_analysis_client import CodeAnalysisAsyncClient
+
+
+async def main() -> None:
+    client = CodeAnalysisAsyncClient(
+        protocol="https",
+        host="127.0.0.1",
+        port=15001,
+        cert="/path/client.crt",
+        key="/path/client.key",
+        ca="/path/ca.crt",
+        timeout=120.0,
+    )
+    async with client:
+        h = await client.rpc.help()
+        r = await client.call("list_projects", {"include_deleted": False})
+    print(h, r)
+
+
+asyncio.run(main())
+```
+
+Build client settings from the same JSON shape as the pipeline adapter settings (`host`, `port`, `protocol`, optional `ssl` with `cert` / `key` / `ca` or `*_path` aliases), or from a full server `config.json` object.
+
+```python
+from code_analysis_client import CodeAnalysisAsyncClient
+
+client = CodeAnalysisAsyncClient.from_server_config(config_dict, timeout=60.0)
+```
+
+Queued/long commands: use `client.call_unified(..., expect_queue=True, auto_poll=True)` or the underlying `client.rpc.execute_command_unified(...)`.
+
+## Validation using the server schema
+
+The authoritative input schema is whatever the running server returns from **`help`** with `cmdname` set to the command. The client calls that, optionally caches the result, performs the same shallow checks as the server’s `BaseMCPCommand` (types, `required`, `enum`, `additionalProperties`), then runs the command.
+
+```python
+async with CodeAnalysisAsyncClient(host="127.0.0.1", port=15001) as client:
+    # Explicit
+    out = await client.call_validated(
+        "list_projects",
+        {"include_deleted": False},
+    )
+    # Dynamic wrapper: same as call_validated("list_projects", {...})
+    out = await client.commands.list_projects(include_deleted=False)
+    # After server reload
+    client.clear_command_schema_cache()
+```
+
+Use `call_unified_validated` when you need queue polling. Pass `refresh_schema=True` on a single call to bypass the in-memory schema cache.
+
+## Examples (this repository)
+
+Runnable scripts live under `client/examples/`. **Long-form “man page” style
+documentation** is embedded in the **module docstrings** of those Python files
+(see `client/examples/README.md` for how to read them). Full API walkthrough:
+`python client/examples/run_all_examples.py` with the daemon up and
+`CODE_ANALYSIS_CONFIG` or default `config.json` at the repo root.
+
+## Development
+
+From the repository root:
+
+```bash
+pip install -e ./client
+pytest tests/test_code_analysis_client.py
+```

code_analysis_client-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+code_analysis_client/__init__.py,sha256=E2j3dr9FzUrPsMm5cp6_EQ4UKPh3vQ2ycd7HSO9jjkg,1517
+code_analysis_client/client.py,sha256=TVOIuV3ttQ8VnsE8xqLA-kA_IbZO3rvc-2QSkBUZVBg,8025
+code_analysis_client/commands_proxy.py,sha256=VbmM-01tvt8b5NDgk5JWd6IVCOxgyDkpehUXl2BvL1o,1969
+code_analysis_client/config.py,sha256=WTV1eAMA4aD8i5b7Ss6piYBqKwtGSyrDcdP-TgFG9TY,4514
+code_analysis_client/exceptions.py,sha256=if-sO2z_qGDeqbvNUnFiXavW0VOzh571zQRTavjpwEo,541
+code_analysis_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+code_analysis_client/server_schema.py,sha256=6auc4WQFiA_2-XQDNVX-8edPtkYCZP4IOzVlePMfYj0,1862
+code_analysis_client/validation.py,sha256=TGgVIwKJ_-5cXnC3fxkP_knokVlrrlL2dlIPxe7tq3U,4079
+code_analysis_client/version.txt,sha256=WYVJhIUxBN9cNT4vaBoV_HkkdC-aLkaMKa8kjc5FzgM,6
+code_analysis_client-1.0.0.dist-info/METADATA,sha256=Vsz_7OGB7ooQgfDN-okbFIQkeFb5SVTbNuCk6pVb-0k,3257
+code_analysis_client-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+code_analysis_client-1.0.0.dist-info/top_level.txt,sha256=NXzwlTVdqyKm43HrnRqBc-DlAeSVkHifJihWZ9JZ2xs,21
+code_analysis_client-1.0.0.dist-info/RECORD,,

code_analysis_client-1.0.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
+

code_analysis_client-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+code_analysis_client