code-analysis-client 1.6.178__tar.gz → 1.6.187__tar.gz

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.178
+Version: 1.6.187
 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.59
+Requires-Dist: mcp-proxy-adapter>=8.10.69
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client/__init__.py

@@ -24,6 +24,18 @@ from code_analysis_client.exceptions import (
     QueueJobError,
 )
 from code_analysis_client.file_session import FileSessionClient, SessionNotFoundError
+from code_analysis_client.check_chain import (
+    CheckChainClient,
+    CheckChainConfigInvalidError,
+    CheckChainError,
+    CheckChainGetResult,
+    CheckChainListResult,
+    ChainElement,
+    Degraded,
+    Diagnostic,
+    ExtensionChain,
+    FileCheckAndPromoteResult,
+)
 from code_analysis_client.worktree import WorktreeClient, WorktreeConflictError
 from code_analysis_client.queue_wait import (
     QueuedJob,
@@ -72,6 +84,16 @@ __all__ = [
     "UNIVERSAL_FILE_COMMANDS",
     "UniversalFileClient",
     "ValidatedCommandsProxy",
+    "CheckChainClient",
+    "CheckChainConfigInvalidError",
+    "CheckChainError",
+    "CheckChainGetResult",
+    "CheckChainListResult",
+    "ChainElement",
+    "Degraded",
+    "Diagnostic",
+    "ExtensionChain",
+    "FileCheckAndPromoteResult",
     "WorktreeClient",
     "WorktreeConflictError",
     "adapter_settings_from_server_config",

code_analysis_client-1.6.187/code_analysis_client/check_chain.py

@@ -0,0 +1,350 @@
+"""
+Check-chain commands on top of CodeAnalysisAsyncClient.
+
+Typed wrappers for ``check_chain_list``, ``check_chain_get`` and
+``file_check_and_promote`` with full parameter mapping and result/error mapping:
+diagnostics, degraded outcomes, sync conflicts and the closed error enum of
+``file_check_and_promote``.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from code_analysis_client.exceptions import ClientValidationError
+from code_analysis_client.responses import command_error_code
+from code_analysis_client.worktree import WorktreeConflictError
+
+if TYPE_CHECKING:
+    from code_analysis_client.client import CodeAnalysisAsyncClient
+
+EXTENSION_PATTERN = r"^\.[A-Za-z0-9]+(\.[A-Za-z0-9]+)*$"
+_EXTENSION_RE = re.compile(EXTENSION_PATTERN)
+
+FCP_ERROR_CODES = frozenset(
+    {
+        "VALIDATION_ERROR",
+        "PROJECT_NOT_FOUND",
+        "PROJECT_LOCKED",
+        "SESSION_NOT_FOUND",
+        "WORKTREE_CREATE_FAILED",
+        "WORKTREE_CREATE_TIMEOUT",
+        "WORKTREE_SYNC_CONFLICT",
+        "WORKTREE_MERGE_IN_PROGRESS",
+        "WORKTREE_REBASE_IN_PROGRESS",
+        "FCP_WRITE_FAILED",
+        "CHECK_CHAIN_CONFIG_INVALID",
+        "FCP_CHECK_TOOL_CRASHED",
+        "FCP_CHECK_TOOL_TIMEOUT",
+        "WORKTREE_COMMIT_FAILED",
+        "FCP_PROMOTE_RACE",
+        "GIT_NOT_AVAILABLE",
+        "GIT_NOT_A_REPO",
+    }
+)
+
+
+class CheckChainError(ClientValidationError):
+    """A check-chain command answered with a server error.
+
+    Attributes:
+        code: the server error code (e.g. ``FCP_PROMOTE_RACE``).
+        details: the server error details/data object.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str,
+        field: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Store the server error code with the message and details."""
+        super().__init__(message, field=field or "command", details=details)
+        self.code = code
+
+
+class CheckChainConfigInvalidError(CheckChainError):
+    """CHECK_CHAIN_CONFIG_INVALID with its section, extension and reason."""
+
+    def __init__(self, message: str, *, details: Optional[Dict[str, Any]] = None) -> None:
+        """Expose details.section/extension/reason as attributes."""
+        super().__init__(
+            message, code="CHECK_CHAIN_CONFIG_INVALID", field="check_chains", details=details
+        )
+        self.section = self.details.get("section")
+        self.extension = self.details.get("extension")
+        self.reason = self.details.get("reason")
+
+
+@dataclass(frozen=True)
+class ChainElement:
+    """One check-chain element."""
+
+    tool: str
+    config_source: str
+    blocking: bool
+    args: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class ExtensionChain:
+    """Resolved chain of one extension."""
+
+    extension: str
+    source: str
+    chain: List[ChainElement]
+
+
+@dataclass(frozen=True)
+class CheckChainListResult:
+    """Result of ``check_chain_list``."""
+
+    project_id: str
+    chains: List[ExtensionChain]
+
+
+@dataclass(frozen=True)
+class CheckChainGetResult:
+    """Result of ``check_chain_get``."""
+
+    project_id: str
+    extension: str
+    source: str
+    chain: List[ChainElement]
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    """One finding of a chain element."""
+
+    tool: str
+    path: str
+    line: Optional[int]
+    column: Optional[int]
+    code: Optional[str]
+    severity: Optional[str]
+    message: str
+
+
+@dataclass(frozen=True)
+class Degraded:
+    """Why a call degraded (nothing promoted)."""
+
+    reason: str
+    tool: Optional[str] = None
+    skipped_tools: List[str] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class FileCheckAndPromoteResult:
+    """Result of ``file_check_and_promote`` (outcome-discriminated).
+
+    ``outcome`` is ``promoted``, ``diagnostics`` or ``degraded``. ``promoted`` is
+    True only for ``promoted``. ``degraded`` may also be set on a promoted outcome
+    when only non-blocking tools were skipped (``skipped_tools``).
+    """
+
+    project_id: str
+    editor_session_id: str
+    path: str
+    outcome: str
+    promoted: bool
+    commit: Optional[str]
+    index_pending: bool
+    index_job_id: Optional[str]
+    index_trigger_error: Optional[str]
+    diagnostics: List[Diagnostic]
+    degraded: Optional[Degraded]
+    raw: Dict[str, Any] = field(default_factory=dict, compare=False, repr=False)
+
+
+def _require_non_empty(value: Any, *, field_name: str) -> str:
+    """Return stripped text or raise ClientValidationError."""
+    text = str(value or "").strip()
+    if not text:
+        raise ClientValidationError(f"{field_name} is required", field=field_name)
+    return text
+
+
+def _error_parts(data: Dict[str, Any]) -> tuple[str, str, Dict[str, Any]]:
+    """Return (code, message, details) of a failed response."""
+    code = command_error_code(data)
+    err = data.get("error")
+    err_dict: Dict[str, Any] = err if isinstance(err, dict) else {}
+    message = data.get("message") or err_dict.get("message") or code or str(data)
+    details = (
+        err_dict.get("details")
+        or err_dict.get("data")
+        or data.get("details")
+        or data.get("data")
+        or {}
+    )
+    return code, str(message), details if isinstance(details, dict) else {}
+
+
+def _success_payload(data: Dict[str, Any], *, command: str) -> Dict[str, Any]:
+    """Return the success data dict, or raise the mapped error for a failure."""
+    if data.get("success"):
+        inner = data.get("data")
+        return inner if isinstance(inner, dict) else data
+    code, message, details = _error_parts(data)
+    if code == "WORKTREE_SYNC_CONFLICT":
+        raise WorktreeConflictError(
+            message,
+            conflicts=details.get("conflicts"),
+            preserved_locked_files=details.get("preserved_locked_files"),
+        )
+    if code == "CHECK_CHAIN_CONFIG_INVALID":
+        raise CheckChainConfigInvalidError(message, details=details)
+    raise CheckChainError(
+        message, code=code or "UNKNOWN", field=details.get("field") or command, details=details
+    )
+
+
+def _element(raw: Any) -> ChainElement:
+    """Map one raw chain element."""
+    item = raw if isinstance(raw, dict) else {}
+    return ChainElement(
+        tool=str(item.get("tool", "")),
+        config_source=str(item.get("config_source", "auto")),
+        blocking=bool(item.get("blocking", False)),
+        args=[str(a) for a in (item.get("args") or [])],
+    )
+
+
+def _diagnostic(raw: Any) -> Diagnostic:
+    """Map one raw diagnostic."""
+    item = raw if isinstance(raw, dict) else {}
+    return Diagnostic(
+        tool=str(item.get("tool", "")),
+        path=str(item.get("path", "")),
+        line=item.get("line"),
+        column=item.get("column"),
+        code=item.get("code"),
+        severity=item.get("severity"),
+        message=str(item.get("message", "")),
+    )
+
+
+def _degraded(raw: Any) -> Optional[Degraded]:
+    """Map the degraded object (None when absent)."""
+    if not isinstance(raw, dict):
+        return None
+    return Degraded(
+        reason=str(raw.get("reason", "")),
+        tool=raw.get("tool"),
+        skipped_tools=[str(t) for t in (raw.get("skipped_tools") or [])],
+    )
+
+
+class CheckChainClient:
+    """check_chain_list / check_chain_get / file_check_and_promote."""
+
+    __slots__ = ("_client",)
+
+    def __init__(self, client: CodeAnalysisAsyncClient) -> None:
+        """Store the underlying async client."""
+        self._client = client
+
+    async def list(self, project_id: str) -> CheckChainListResult:
+        """Return the resolved chain of every configured extension.
+
+        Calls ``check_chain_list``. Raises CheckChainConfigInvalidError for a
+        malformed registry entry and CheckChainError for other server errors.
+        """
+        project_id = _require_non_empty(project_id, field_name="project_id")
+        data = await self._client.call_validated(
+            "check_chain_list", {"project_id": project_id}
+        )
+        payload = _success_payload(data, command="check_chain_list")
+        return CheckChainListResult(
+            project_id=str(payload.get("project_id", project_id)),
+            chains=[
+                ExtensionChain(
+                    extension=str(entry.get("extension", "")),
+                    source=str(entry.get("source", "empty")),
+                    chain=[_element(e) for e in (entry.get("chain") or [])],
+                )
+                for entry in (payload.get("chains") or [])
+                if isinstance(entry, dict)
+            ],
+        )
+
+    async def get(self, project_id: str, extension: str) -> CheckChainGetResult:
+        """Return the resolved chain of one extension (leading dot required).
+
+        Calls ``check_chain_get``. An unconfigured extension is source ``empty``
+        with an empty chain.
+        """
+        project_id = _require_non_empty(project_id, field_name="project_id")
+        extension = _require_non_empty(extension, field_name="extension")
+        if not _EXTENSION_RE.match(extension):
+            raise ClientValidationError(
+                f"extension must match {EXTENSION_PATTERN}", field="extension"
+            )
+        data = await self._client.call_validated(
+            "check_chain_get", {"project_id": project_id, "extension": extension}
+        )
+        payload = _success_payload(data, command="check_chain_get")
+        return CheckChainGetResult(
+            project_id=str(payload.get("project_id", project_id)),
+            extension=str(payload.get("extension", extension)),
+            source=str(payload.get("source", "empty")),
+            chain=[_element(e) for e in (payload.get("chain") or [])],
+        )
+
+    async def file_check_and_promote(
+        self,
+        project_id: str,
+        editor_session_id: str,
+        path: str,
+        content: str,
+    ) -> FileCheckAndPromoteResult:
+        """Write, check and promote one file through the editor's worktree.
+
+        Calls ``file_check_and_promote``. Diagnostics and degraded outcomes are
+        successful results (``outcome`` / ``promoted``), never exceptions.
+        Raises WorktreeConflictError on WORKTREE_SYNC_CONFLICT (with
+        ``conflicts`` and ``preserved_locked_files``), CheckChainConfigInvalidError
+        for a malformed registry entry, and CheckChainError (``code`` from the
+        closed enum, e.g. FCP_PROMOTE_RACE) for every other server error.
+        """
+        project_id = _require_non_empty(project_id, field_name="project_id")
+        editor_session_id = _require_non_empty(
+            editor_session_id, field_name="editor_session_id"
+        )
+        path = _require_non_empty(path, field_name="path")
+        if not isinstance(content, str):
+            raise ClientValidationError("content must be a string", field="content")
+        data = await self._client.call_validated(
+            "file_check_and_promote",
+            {
+                "project_id": project_id,
+                "editor_session_id": editor_session_id,
+                "path": path,
+                "content": content,
+            },
+        )
+        payload = _success_payload(data, command="file_check_and_promote")
+        outcome = str(payload.get("outcome", ""))
+        return FileCheckAndPromoteResult(
+            project_id=str(payload.get("project_id", project_id)),
+            editor_session_id=str(payload.get("editor_session_id", editor_session_id)),
+            path=str(payload.get("path", path)),
+            outcome=outcome,
+            promoted=bool(payload.get("promoted", outcome == "promoted")),
+            commit=payload.get("commit"),
+            index_pending=bool(payload.get("index_pending", False)),
+            index_job_id=payload.get("index_job_id"),
+            index_trigger_error=payload.get("index_trigger_error"),
+            diagnostics=[_diagnostic(d) for d in (payload.get("diagnostics") or [])],
+            degraded=_degraded(payload.get("degraded")),
+            raw=payload,
+        )

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client/client.py

@@ -15,6 +15,7 @@ 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 mcp_proxy_adapter.client.jsonrpc_client.exceptions import ClientRemoteResponseError
 
 from code_analysis_client.commands_proxy import ValidatedCommandsProxy
 from code_analysis_client.config import (
@@ -23,6 +24,7 @@ from code_analysis_client.config import (
     load_server_config,
 )
 from code_analysis_client.file_session import FileSessionClient
+from code_analysis_client.check_chain import CheckChainClient
 from code_analysis_client.worktree import WorktreeClient
 from code_analysis_client.queue_wait import (
     QueuedJob,
@@ -39,12 +41,40 @@ from code_analysis_client.schema_disk_cache import (
     store_cached_schema,
 )
 from code_analysis_client.server_schema import fetch_command_schema_from_server
+from code_analysis_client.exceptions import ClientValidationError
 from code_analysis_client.validation import (
     prepare_params_for_schema,
     validate_params_against_schema,
 )
 
 
+def _remote_invalid_params_as_client_validation(
+    error: ClientRemoteResponseError,
+) -> ClientValidationError | None:
+    """Convert the adapter's JSON-RPC invalid-params response for client callers.
+
+    ``JsonRpcClient.execute_command()`` raises ``ClientRemoteResponseError``
+    for every top-level JSON-RPC error.  Code-analysis validation errors use
+    the standard ``-32602`` code, however, and callers of this package already
+    handle local schema failures as ``ClientValidationError``.  Preserve the
+    adapter's complete message and the server's validation payload while
+    presenting both local and remote invalid-parameter failures through that
+    one client contract.
+    """
+    details = error.details
+    if details.get("code") != -32602:
+        return None
+
+    payload = details.get("data")
+    payload = payload if isinstance(payload, dict) else {}
+    field = payload.get("field")
+    return ClientValidationError(
+        str(error),
+        field=field if isinstance(field, str) else "command",
+        details=payload,
+    )
+
+
 class CodeAnalysisAsyncClient:
     """Async client: domain commands via :meth:`call` / :meth:`call_unified`; full adapter API on :attr:`rpc`."""
 
@@ -153,6 +183,11 @@ class CodeAnalysisAsyncClient:
         """Worktree management: ``worktree_*`` commands."""
         return WorktreeClient(self)
 
+    @property
+    def check_chains(self) -> CheckChainClient:
+        """Check-chain registry and promote: ``check_chain_*``, ``file_check_and_promote``."""
+        return CheckChainClient(self)
+
     @property
     def universal_files(self) -> UniversalFileClient:
         """Read-only structured preview (``universal_file_preview`` command)."""
@@ -220,10 +255,16 @@ class CodeAnalysisAsyncClient:
 
         A non-queued response is returned unchanged regardless of ``auto_poll``.
         """
-        resp = await self._rpc.execute_command(
-            command,
-            params or {},
-        )
+        try:
+            resp = await self._rpc.execute_command(
+                command,
+                params or {},
+            )
+        except ClientRemoteResponseError as exc:
+            validation_error = _remote_invalid_params_as_client_validation(exc)
+            if validation_error is None:
+                raise
+            raise validation_error from exc
         if not is_queued_envelope(resp):
             return resp
 
@@ -240,6 +281,45 @@ class CodeAnalysisAsyncClient:
         )
         return await unwrap_job_result(status, rpc=self._rpc)
 
+    async def _execute_validated(
+        self,
+        command: str,
+        params: Dict[str, Any],
+        *,
+        use_cmd_endpoint: bool,
+        auto_poll: bool,
+        timeout: Optional[float],
+        poll_interval: float,
+        status_hook: Optional[StatusHook],
+    ) -> Union[Dict[str, Any], QueuedJob]:
+        """Execute after schema validation and reconcile a stale command catalog.
+
+        A cached schema can outlive a deployment that removes its command.  If
+        execution reports JSON-RPC ``-32601``, discard the cached catalog view
+        and ask live ``help`` once.  A command still present keeps the original
+        remote error; an absent command surfaces ``help``'s
+        :class:`ClientValidationError` with the remote response as its cause.
+        """
+        try:
+            return await self._execute(
+                command,
+                params,
+                use_cmd_endpoint=use_cmd_endpoint,
+                auto_poll=auto_poll,
+                timeout=timeout,
+                poll_interval=poll_interval,
+                status_hook=status_hook,
+            )
+        except ClientRemoteResponseError as exc:
+            if exc.details.get("code") != -32601:
+                raise
+            self.clear_command_schema_cache()
+            try:
+                await self.get_command_schema(command, refresh=True)
+            except ClientValidationError as schema_error:
+                raise schema_error from exc
+            raise
+
     @overload
     async def call_validated(
         self,
@@ -304,7 +384,7 @@ class CodeAnalysisAsyncClient:
         merged = dict(params or {})
         prepared = prepare_params_for_schema(merged, schema)
         validate_params_against_schema(prepared, schema, command_name=command)
-        return await self._execute(
+        return await self._execute_validated(
             command,
             prepared,
             use_cmd_endpoint=use_cmd_endpoint,
@@ -394,7 +474,7 @@ class CodeAnalysisAsyncClient:
         merged = dict(params or {})
         prepared = prepare_params_for_schema(merged, schema)
         validate_params_against_schema(prepared, schema, command_name=command)
-        return await self._execute(
+        return await self._execute_validated(
             command,
             prepared,
             use_cmd_endpoint=use_cmd_endpoint,

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client/exceptions.py

@@ -15,6 +15,8 @@ from typing import Any, Dict, Optional
 class ClientValidationError(ValueError):
     """Parameters do not match the command JSON schema (from server ``help``)."""
 
+    code = "VALIDATION_ERROR"
+
     def __init__(
         self,
         message: str,

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client/file_session.py

@@ -123,11 +123,17 @@ class FileSessionClient:
         comment: str,
         *,
         role_ids: Optional[List[str]] = None,
+        session_id: Optional[str] = None,
+        is_foreign: Optional[bool] = None,
     ) -> str:
-        """Create a client session (``session_create``) and return ``session_id``."""
+        """Create a client session with an optional ID and ownership marker."""
         params: Dict[str, Any] = {"comment": comment}
         if role_ids is not None:
             params["role_ids"] = role_ids
+        if session_id is not None:
+            params["session_id"] = session_id
+        if is_foreign is not None:
+            params["is_foreign"] = is_foreign
         payload = _unwrap(await self._client.call_validated("session_create", params))
         sid = str(payload.get("session_id") or "").strip()
         if not sid:
@@ -177,6 +183,17 @@ class FileSessionClient:
             )
         )
 
+    async def delete_foreign_session(
+        self, session_id: str, *, force: bool = False
+    ) -> Dict[str, Any]:
+        """Explicitly delete a caller-ID session (``session_delete_foreign``)."""
+        params: Dict[str, Any] = {"session_id": _require_non_empty(session_id, field="session_id")}
+        if force:
+            params["force"] = True
+        return _unwrap(
+            await self._client.call_validated("session_delete_foreign", params)
+        )
+
     async def view_session(self, session_id: str) -> Dict[str, Any]:
         """Aggregated session view (``session_view``).
 

code_analysis_client-1.6.187/code_analysis_client/version.txt

@@ -0,0 +1 @@
+1.6.187

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.6.178
+Version: 1.6.187
 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.59
+Requires-Dist: mcp-proxy-adapter>=8.10.69
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 README.md
 pyproject.toml
 code_analysis_client/__init__.py
+code_analysis_client/check_chain.py
 code_analysis_client/client.py
 code_analysis_client/commands_proxy.py
 code_analysis_client/config.py

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/code_analysis_client.egg-info/requires.txt

@@ -1,4 +1,4 @@
-mcp-proxy-adapter>=8.10.59
+mcp-proxy-adapter>=8.10.69
 
 [dev]
 pytest>=8.0

{code_analysis_client-1.6.178 → code_analysis_client-1.6.187}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
     { name = "Vasiliy Zdanovskiy", email = "vasilyvz@gmail.com" },
 ]
 dependencies = [
-    "mcp-proxy-adapter>=8.10.59",
+    "mcp-proxy-adapter>=8.10.69",
 ]
 
 [project.optional-dependencies]

code_analysis_client-1.6.178/code_analysis_client/version.txt

@@ -1 +0,0 @@
-1.6.178