code-analysis-client 1.0.6__tar.gz → 1.6.39__tar.gz

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.0.6
+Version: 1.6.39
 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.13
+Requires-Dist: mcp-proxy-adapter>=8.10.15
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
@@ -97,8 +97,8 @@ Sync checks (in-process registry):
 pytest tests/test_client_server_api_sync.py tests/test_code_analysis_client.py -k session
 ```
 
-Package version is in ``client/code_analysis_client/version.txt`` (synced with the
-root ``code-analysis`` project via ``scripts/sync_code_analysis_client_version.py``).
+Package version is in the root ``pyproject.toml``; before a client wheel build run
+``python scripts/sync_code_analysis_client_version.py`` (also done by ``release_build.sh``).
 
 ## Examples (this repository)
 

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/README.md

@@ -85,8 +85,8 @@ Sync checks (in-process registry):
 pytest tests/test_client_server_api_sync.py tests/test_code_analysis_client.py -k session
 ```
 
-Package version is in ``client/code_analysis_client/version.txt`` (synced with the
-root ``code-analysis`` project via ``scripts/sync_code_analysis_client_version.py``).
+Package version is in the root ``pyproject.toml``; before a client wheel build run
+``python scripts/sync_code_analysis_client_version.py`` (also done by ``release_build.sh``).
 
 ## Examples (this repository)
 

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/__init__.py

@@ -25,6 +25,7 @@ from code_analysis_client.server_api import (
     FILE_SESSION_FACADE_METHODS,
     LEGACY_REMOVED_COMMANDS,
     REMOVED_COMMANDS,
+    TRANSFER_FACADE_METHODS,
     UNIVERSAL_FILE_COMMANDS,
 )
 from code_analysis_client.universal_file import UniversalFileClient
@@ -48,6 +49,7 @@ __all__ = [
     "LEGACY_REMOVED_COMMANDS",
     "REMOVED_COMMANDS",
     "SessionNotFoundError",
+    "TRANSFER_FACADE_METHODS",
     "UNIVERSAL_FILE_COMMANDS",
     "UniversalFileClient",
     "ValidatedCommandsProxy",
@@ -62,6 +64,7 @@ __all__ = [
 
 
 def _read_package_version() -> str:
+    """Read installed client version from version.txt or package metadata."""
     vf = Path(__file__).resolve().parent / "version.txt"
     if vf.is_file():
         return vf.read_text(encoding="utf-8").strip()

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/client.py

@@ -228,10 +228,13 @@ class CodeAnalysisAsyncClient:
         )
 
     async def close(self) -> None:
+        """Close the underlying JSON-RPC transport."""
         await self._rpc.close()
 
     async def __aenter__(self) -> CodeAnalysisAsyncClient:
+        """Enter async context manager and return this client."""
         return self
 
     async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        """Close the client when leaving an async context manager block."""
         await self.close()

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/commands_proxy.py

@@ -19,6 +19,7 @@ class ValidatedCommandsProxy:
     __slots__ = ("_client",)
 
     def __init__(self, client: CodeAnalysisAsyncClient) -> None:
+        """Store the client used for schema lookup and validated command calls."""
         object.__setattr__(self, "_client", client)
 
     def clear_schema_cache(self) -> None:
@@ -47,10 +48,12 @@ class ValidatedCommandsProxy:
         return cast(Dict[str, Any], await self._client.call_validated(command, merged))
 
     def __getattr__(self, name: str) -> Any:
+        """Return an async validated-call wrapper for an arbitrary command name."""
         if name.startswith("_"):
             raise AttributeError(name)
 
         async def _bound(**kw: Any) -> Dict[str, Any]:
+            """Execute the dynamically selected command with validated keyword params."""
             return cast(Dict[str, Any], await self._client.call_validated(name, kw))
 
         _bound.__name__ = name

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/config.py

@@ -13,12 +13,14 @@ from typing import Any, Mapping
 
 
 def _expand_path(value: Any) -> str | None:
+    """Expand a non-empty filesystem path value to an absolute string."""
     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]:
+    """Extract and normalize TLS path fields from a config SSL section."""
     if not isinstance(ssl_section, dict):
         return {}
     out: dict[str, str] = {}
@@ -38,6 +40,7 @@ def _ssl_paths_from_section(ssl_section: Any) -> dict[str, str]:
 
 
 def _network_from_server_config(config: Mapping[str, Any]) -> dict[str, Any]:
+    """Return host, port, and protocol settings from a server config dict."""
     server = config.get("server", {})
     if not isinstance(server, dict):
         server = {}

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/exceptions.py

@@ -15,6 +15,7 @@ class ClientValidationError(ValueError):
         field: Optional[str] = None,
         details: Optional[Dict[str, Any]] = None,
     ) -> None:
+        """Initialize validation error with optional field and details payload."""
         super().__init__(message)
         self.field = field
         self.details = details or {}

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/file_session.py

@@ -4,6 +4,21 @@ High-level file transfer and session workflow on top of CodeAnalysisAsyncClient.
 Wraps ``session_*`` and ``subordinate_session_*`` MCP commands plus transfer and
 advisory-lock commands that accept ``session_id``.
 
+Transfer mapping (client façade → server command):
+
+* **Download** — ``download`` → ``project_file_transfer_download_begin`` (``file_id``
+  required; optional ``project_id`` scopes the lookup). Chunk streaming uses the
+  adapter ``download_file`` helper via ``download_to_path``.
+* **Upload** — two façade methods share one save command
+  ``project_file_transfer_upload_save``:
+
+  - ``upload`` — update mode: ``file_id`` only (overwrite an indexed file).
+  - ``upload_new`` — create mode: ``project_id`` + ``file_path`` (path must not
+    be indexed yet).
+
+  Both methods upload bytes through the adapter, then call the same save command
+  with the completed ``transfer_id``.
+
 Author: Vasiliy Zdanovskiy
 email: vasilyvz@gmail.com
 """
@@ -25,6 +40,7 @@ class SessionNotFoundError(ClientValidationError):
 
 
 def _unwrap(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Unwrap command result payloads and map missing sessions to SessionNotFoundError."""
     return unwrap_command_result(
         data,
         session_not_found_type=SessionNotFoundError,
@@ -32,6 +48,7 @@ def _unwrap(data: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def _require_non_empty(value: str, *, field: str) -> str:
+    """Return stripped text or raise ClientValidationError for an empty field."""
     text = str(value or "").strip()
     if not text:
         raise ClientValidationError(f"{field} is required", field=field)
@@ -39,13 +56,43 @@ def _require_non_empty(value: str, *, field: str) -> str:
 
 
 def _validate_download_target(*, file_id: Optional[str]) -> None:
-    """Download requires ``file_id``."""
+    """Download requires ``file_id`` (server rejects ``file_path``)."""
     fid = str(file_id or "").strip()
     if not fid:
         raise ClientValidationError("file_id is required", field="file_id")
 
 
+def _validate_upload_selector(
+    *,
+    file_id: Optional[str] = None,
+    file_path: Optional[str] = None,
+    project_id: Optional[str] = None,
+) -> None:
+    """Mirror server ``_validate_upload_selector_params`` for save payloads."""
+    fid = str(file_id or "").strip()
+    fp = str(file_path or "").strip()
+    pid = str(project_id or "").strip()
+    if fid and fp:
+        raise ClientValidationError(
+            "Specify exactly one of file_id or file_path, not both",
+            field="file_id",
+        )
+    if fid:
+        return
+    if not pid:
+        raise ClientValidationError(
+            "project_id is required when file_id is omitted",
+            field="project_id",
+        )
+    if not fp:
+        raise ClientValidationError(
+            "file_path is required when file_id is omitted",
+            field="file_path",
+        )
+
+
 def _lock_mode_from_flag(lock: bool) -> str:
+    """Convert a boolean lock flag into the server lock_mode value."""
     return "full" if lock else "none"
 
 
@@ -67,6 +114,7 @@ class FileSessionClient:
     __slots__ = ("_client",)
 
     def __init__(self, client: CodeAnalysisAsyncClient) -> None:
+        """Store the underlying async client used to call session commands."""
         self._client = client
 
     async def create_session(
@@ -89,17 +137,19 @@ class FileSessionClient:
             )
         return sid
 
+    async def validate_session(
+        self, session_id: str, *, touch: bool = False
+    ) -> Dict[str, Any]:
+        """Confirm ``session_id`` exists (``session_validate``)."""
+        sid = _require_non_empty(session_id, field="session_id")
+        params: Dict[str, Any] = {"session_id": sid}
+        if touch:
+            params["touch"] = True
+        return _unwrap(await self._client.call_validated("session_validate", params))
+
     async def assert_session_exists(self, session_id: str) -> None:
-        """Verify ``session_id`` is registered (touch via ``session_list_file_locks``)."""
-        sid = str(session_id).strip()
-        if not sid:
-            raise ClientValidationError("session_id is required", field="session_id")
-        _unwrap(
-            await self._client.call_validated(
-                "session_list_file_locks",
-                {"session_id": sid},
-            )
-        )
+        """Verify ``session_id`` is registered (``session_validate``)."""
+        await self.validate_session(session_id, touch=False)
 
     async def delete_session(
         self, session_id: str, *, force: bool = False
@@ -107,12 +157,14 @@ class FileSessionClient:
         """Delete a client session (``session_delete``).
 
         ``force`` defaults to false (omit on the wire when false). Safe delete
-        requires no ``session_file_locks`` and no ``subordinate_sessions`` rows
-        where this session is ``parent_session_id``. When ``force`` is true,
-        linked subordinate client sessions and file locks are removed first.
-
-        Returns ``session_id``, ``deleted``, ``released_lock_count``, and
-        ``released_subordinate_count``.
+        requires no ``session_file_locks``, no ``subordinate_sessions`` rows
+        where this session is ``parent_session_id``, and no advisory file-lock
+        leases. When ``force`` is true, subordinate link rows, DB file locks, and
+        advisory leases for this session are released before the session row is
+        deleted.
+
+        Returns ``session_id``, ``deleted``, ``released_lock_count``,
+        ``released_subordinate_count``, and ``released_advisory_lease_count``.
         """
         params: Dict[str, Any] = {"session_id": session_id}
         if force:
@@ -129,8 +181,8 @@ class FileSessionClient:
 
         Returns ``locked_files_by_project`` (file_id, file_path,
         project_presentation per project) and ``subordinate_sessions``
-        (subordinate_session_id, server_uuid, session_presentation,
-        server_presentation, link_comment).
+        (session_id, server_uuid, session_presentation, server_presentation,
+        link_comment).
         """
         sid = _require_non_empty(session_id, field="session_id")
         return _unwrap(
@@ -143,13 +195,13 @@ class FileSessionClient:
     async def create_subordinate_session(
         self,
         parent_session_id: str,
-        subordinate_session_id: str,
         comment: str,
         *,
         server_uuid: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """Link subordinate to parent (``subordinate_session_create``).
+        """Register leading session on a subordinate server (``subordinate_session_create``).
 
+        Subordinate servers use ``parent_session_id`` as ``session_id``.
         ``server_uuid`` defaults to the server's ``registration.instance_uuid``
         when omitted.
         """
@@ -157,9 +209,6 @@ class FileSessionClient:
             "parent_session_id": _require_non_empty(
                 parent_session_id, field="parent_session_id"
             ),
-            "subordinate_session_id": _require_non_empty(
-                subordinate_session_id, field="subordinate_session_id"
-            ),
             "comment": comment,
         }
         if server_uuid is not None:
@@ -171,10 +220,9 @@ class FileSessionClient:
     async def get_subordinate_session(
         self,
         parent_session_id: str,
-        subordinate_session_id: str,
         server_uuid: str,
     ) -> Dict[str, Any]:
-        """Fetch one subordinate link (``subordinate_session_get``)."""
+        """Fetch one subordinate server link (``subordinate_session_get``)."""
         return _unwrap(
             await self._client.call_validated(
                 "subordinate_session_get",
@@ -182,9 +230,6 @@ class FileSessionClient:
                     "parent_session_id": _require_non_empty(
                         parent_session_id, field="parent_session_id"
                     ),
-                    "subordinate_session_id": _require_non_empty(
-                        subordinate_session_id, field="subordinate_session_id"
-                    ),
                     "server_uuid": _require_non_empty(server_uuid, field="server_uuid"),
                 },
             )
@@ -193,7 +238,6 @@ class FileSessionClient:
     async def update_subordinate_session(
         self,
         parent_session_id: str,
-        subordinate_session_id: str,
         server_uuid: str,
         comment: str,
     ) -> Dict[str, Any]:
@@ -205,9 +249,6 @@ class FileSessionClient:
                     "parent_session_id": _require_non_empty(
                         parent_session_id, field="parent_session_id"
                     ),
-                    "subordinate_session_id": _require_non_empty(
-                        subordinate_session_id, field="subordinate_session_id"
-                    ),
                     "server_uuid": _require_non_empty(server_uuid, field="server_uuid"),
                     "comment": comment,
                 },
@@ -217,12 +258,11 @@ class FileSessionClient:
     async def delete_subordinate_session(
         self,
         parent_session_id: str,
-        subordinate_session_id: str,
         server_uuid: str,
     ) -> Dict[str, Any]:
-        """Remove subordinate link only (``subordinate_session_delete``).
+        """Remove subordinate server link (``subordinate_session_delete``).
 
-        Does not delete ``client_sessions`` rows; use :meth:`delete_session` for that.
+        Does not delete the leading ``client_sessions`` row; use :meth:`delete_session`.
         """
         return _unwrap(
             await self._client.call_validated(
@@ -231,9 +271,6 @@ class FileSessionClient:
                     "parent_session_id": _require_non_empty(
                         parent_session_id, field="parent_session_id"
                     ),
-                    "subordinate_session_id": _require_non_empty(
-                        subordinate_session_id, field="subordinate_session_id"
-                    ),
                     "server_uuid": _require_non_empty(server_uuid, field="server_uuid"),
                 },
             )
@@ -243,18 +280,15 @@ class FileSessionClient:
         self,
         *,
         parent_session_id: Optional[str] = None,
-        subordinate_session_id: Optional[str] = None,
         server_uuid: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """List subordinate links (``subordinate_session_list``).
+        """List subordinate server links (``subordinate_session_list``).
 
         Returns ``links`` and ``count``. All filter parameters are optional.
         """
         params: Dict[str, Any] = {}
         if parent_session_id is not None:
             params["parent_session_id"] = parent_session_id
-        if subordinate_session_id is not None:
-            params["subordinate_session_id"] = subordinate_session_id
         if server_uuid is not None:
             params["server_uuid"] = server_uuid
         return _unwrap(
@@ -391,9 +425,10 @@ class FileSessionClient:
         compression: str = "identity",
         lock: bool = True,
         chunk_size: Optional[int] = None,
-        include_backup_history: bool = False,
+        include_backup_history: bool = True,
+        project_id: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """Begin chunked download; returns payload including ``file_id`` and ``transfer_id``."""
+        """Internal: call ``project_file_transfer_download_begin``."""
         fid = _require_non_empty(file_id, field="file_id")
         _validate_download_target(file_id=fid)
         await self.assert_session_exists(session_id)
@@ -406,6 +441,8 @@ class FileSessionClient:
         }
         if chunk_size is not None:
             params["chunk_size"] = chunk_size
+        if project_id is not None:
+            params["project_id"] = _require_non_empty(project_id, field="project_id")
         payload = _unwrap(
             await self._client.call_validated(
                 "project_file_transfer_download_begin",
@@ -423,9 +460,14 @@ class FileSessionClient:
         *,
         compression: str = "identity",
         lock: bool = True,
-        include_backup_history: bool = False,
+        include_backup_history: bool = True,
+        project_id: Optional[str] = None,
     ) -> Tuple[Dict[str, Any], Any]:
-        """Download an indexed file by ``file_id``; returns (begin_payload, receipt)."""
+        """Download an indexed file by ``file_id`` (``project_file_transfer_download_begin``).
+
+        Returns ``(begin_payload, adapter_receipt)``. ``file_path`` is not accepted —
+        resolve ``file_id`` from ``list_project_files`` or ``session_view`` first.
+        """
         fid = _require_non_empty(file_id, field="file_id")
         begin = await self._begin_download(
             session_id,
@@ -433,6 +475,7 @@ class FileSessionClient:
             compression=compression,
             lock=lock,
             include_backup_history=include_backup_history,
+            project_id=project_id,
         )
         transfer_id = str(begin.get("transfer_id") or "").strip()
         if not transfer_id:
@@ -486,8 +529,19 @@ class FileSessionClient:
         unlock_after_write: bool = True,
         dry_run: bool = False,
         backup: bool = True,
+        diff: bool = False,
+        diff_context_lines: Optional[int] = None,
+        commit_message: Optional[str] = None,
+        validate_syntax_only: bool = False,
+        tree_id: Optional[str] = None,
+        lock_mode: Optional[str] = None,
     ) -> Dict[str, Any]:
         """Persist a completed adapter upload (``project_file_transfer_upload_save``)."""
+        _validate_upload_selector(
+            file_id=file_id,
+            file_path=file_path,
+            project_id=project_id,
+        )
         await self.assert_session_exists(session_id)
         params: Dict[str, Any] = {
             "session_id": session_id,
@@ -502,6 +556,18 @@ class FileSessionClient:
             params["file_id"] = file_id
         if file_path is not None:
             params["file_path"] = file_path
+        if diff:
+            params["diff"] = True
+        if diff_context_lines is not None:
+            params["diff_context_lines"] = diff_context_lines
+        if commit_message is not None:
+            params["commit_message"] = commit_message
+        if validate_syntax_only:
+            params["validate_syntax_only"] = True
+        if tree_id is not None:
+            params["tree_id"] = tree_id
+        if lock_mode is not None:
+            params["lock_mode"] = lock_mode
         return _unwrap(
             await self._client.call_validated(
                 "project_file_transfer_upload_save",
@@ -521,11 +587,18 @@ class FileSessionClient:
         unlock: bool = True,
         dry_run: bool = False,
         backup: bool = True,
+        diff: bool = False,
+        diff_context_lines: Optional[int] = None,
+        commit_message: Optional[str] = None,
+        validate_syntax_only: bool = False,
+        tree_id: Optional[str] = None,
+        lock_mode: Optional[str] = None,
     ) -> str:
-        """Create a new project file from uploaded bytes; returns the new ``file_id``.
+        """Create a new project file (``project_file_transfer_upload_save`` create mode).
 
-        ``project_id`` and project-relative ``file_path`` are required. The path must
-        not already be indexed in the database (new file). Server errors otherwise.
+        Pass ``project_id`` and project-relative ``file_path`` only — do not pass
+        ``file_id``. The path must not already be indexed (``FILE_ALREADY_INDEXED``
+        otherwise). Returns the new ``file_id`` (may be empty on ``dry_run``).
         """
         pid = _require_non_empty(project_id, field="project_id")
         fp = _require_non_empty(file_path, field="file_path")
@@ -549,6 +622,12 @@ class FileSessionClient:
             unlock_after_write=unlock,
             backup=backup,
             dry_run=dry_run,
+            diff=diff,
+            diff_context_lines=diff_context_lines,
+            commit_message=commit_message,
+            validate_syntax_only=validate_syntax_only,
+            tree_id=tree_id,
+            lock_mode=lock_mode,
         )
         if dry_run:
             fid = str(saved.get("file_id") or "").strip()
@@ -561,16 +640,23 @@ class FileSessionClient:
         payload: bytes,
         file_id: str,
         *,
+        project_id: Optional[str] = None,
         filename: Optional[str] = None,
         compression: str = "identity",
         unlock: bool = True,
         backup: bool = True,
         dry_run: bool = False,
+        diff: bool = False,
+        diff_context_lines: Optional[int] = None,
+        commit_message: Optional[str] = None,
+        validate_syntax_only: bool = False,
+        tree_id: Optional[str] = None,
+        lock_mode: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """Overwrite an existing indexed file from uploaded bytes.
+        """Overwrite an existing indexed file (``project_file_transfer_upload_save`` update mode).
 
-        Only ``file_id`` is required. Returns the server save payload on success
-        or raises :class:`ClientValidationError` on failure.
+        Pass ``file_id`` only. Optional ``project_id`` must match the row if provided.
+        Do not pass ``file_path``. Returns the server save payload.
         """
         fid = _require_non_empty(file_id, field="file_id")
         name = filename or "payload.bin"
@@ -589,9 +675,16 @@ class FileSessionClient:
             session_id,
             str(receipt.transfer_id),
             file_id=fid,
+            project_id=project_id,
             unlock_after_write=unlock,
             backup=backup,
             dry_run=dry_run,
+            diff=diff,
+            diff_context_lines=diff_context_lines,
+            commit_message=commit_message,
+            validate_syntax_only=validate_syntax_only,
+            tree_id=tree_id,
+            lock_mode=lock_mode,
         )
         if not dry_run:
             _extract_file_id(saved)

code_analysis_client-1.6.39/code_analysis_client/server_api.py

@@ -0,0 +1,285 @@
+"""
+Canonical command names for the high-level client API vs the live server registry.
+
+**code-analysis-server** owns project trees, the index database, sessions, locks,
+and editor ingress (chunked transfer). It does **not** expose in-server content
+editing (``universal_file_open/edit/write/close``, CST/JSON tree modify/save,
+``format_code``, legacy line writers).
+
+**File content on CA** — read-only surface only:
+
+- :data:`FILE_CONTENT_READ_COMMANDS` — preview and project search (``search`` /
+  ``search_get_page``); on-disk grep is internal to ``search`` when enabled.
+- :data:`FS_COMMANDS` — filesystem operations (copy/move/remove/list/grep); not
+  the structured edit workflow.
+
+Editor clients use :data:`CLIENT_FACADE_COMMANDS` (sessions, transfer, locks,
+``universal_file_preview``).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, FrozenSet, Tuple
+
+# Removed from the public server surface — do not use in client facades or docs.
+LEGACY_REMOVED_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "universal_file_read",
+        "universal_file_save",
+        "universal_file_replace",
+        "universal_file_delete",
+        "read_project_text_file",
+        "write_project_text_lines",
+        "create_text_file",
+        "replace_file_lines",
+        "universal_file_search",
+    }
+)
+
+# CST / JSON tree MCP workflow — modules may exist in the repo but are not registered.
+CST_REMOVED_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "cst_load_file",
+        "cst_save_tree",
+        "cst_modify_tree",
+        "cst_create_file",
+        "cst_find_node",
+        "cst_get_node_info",
+        "cst_get_node_by_range",
+        "cst_get_node_at_line",
+        "cst_reload_tree",
+        "cst_convert_and_save",
+        "cst_apply_buffer",
+        "cst_list_trees",
+        "cst_unload_tree",
+        "list_cst_blocks",
+        "query_cst",
+        "json_load_file",
+        "json_find_node",
+        "json_get_node_info",
+        "json_modify_tree",
+        "json_save_tree",
+        "json_reload_tree",
+    }
+)
+
+# Content editing on ai-editor-server only (not on code-analysis-server).
+EDITING_REMOVED_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "universal_file_open",
+        "universal_file_edit",
+        "universal_file_write",
+        "universal_file_close",
+        "universal_file_move_nodes",
+        "session_git_log",
+        "session_git_diff",
+        "session_git_show",
+        "session_git_status",
+        "session_git_revert",
+        "session_undo",
+        "session_redo",
+        "session_write",
+        "delete_file",
+        "delete_files_by_mask",
+        "restore_deleted_files",
+        "unmark_deleted_file",
+        "cleanup_deleted_files",
+        "collapse_versions",
+        "restore_backup_file",
+        "delete_backup",
+        "clear_all_backups",
+        "split_class",
+        "extract_superclass",
+        "split_file_to_package",
+        "format_code",
+    }
+)
+
+REMOVED_COMMANDS: FrozenSet[str] = (
+    LEGACY_REMOVED_COMMANDS | CST_REMOVED_COMMANDS | EDITING_REMOVED_COMMANDS
+)
+
+# Read-only file **content** on CA (no mutate/edit workflow). Includes on-disk search
+# (``fs_grep``, paginated ``search_*``) for paths not yet in the index.
+FILE_CONTENT_READ_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "universal_file_preview",
+        "get_file_lines",
+        "search",
+        "search_get_page",
+        "search_get_status",
+        "search_cancel",
+        "search_close",
+    }
+)
+
+# Filesystem helpers — separate from structured content editing; may touch paths/bytes
+# via copy/move/remove but are not universal_file_edit / CST / format_code.
+FS_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "fs_copy",
+        "fs_move",
+        "fs_remove",
+    }
+)
+
+# Client sessions + DB file locks — persisted on this server for editor/terminal clients.
+FILE_SESSION_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "session_create",
+        "session_validate",
+        "session_delete",
+        "session_list",
+        "session_view",
+        "session_open_file",
+        "session_close_file",
+        "session_list_file_locks",
+        "subordinate_session_create",
+        "subordinate_session_get",
+        "subordinate_session_update",
+        "subordinate_session_delete",
+        "subordinate_session_list",
+    }
+)
+
+TRANSFER_AND_LOCK_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "project_file_transfer_download_begin",
+        "project_file_transfer_upload_save",
+        "project_file_advisory_lock_batch",
+    }
+)
+
+UNIVERSAL_FILE_COMMANDS: FrozenSet[str] = frozenset(
+    {
+        "universal_file_preview",
+    }
+)
+
+CLIENT_FACADE_COMMANDS: FrozenSet[str] = (
+    FILE_SESSION_COMMANDS | TRANSFER_AND_LOCK_COMMANDS | UNIVERSAL_FILE_COMMANDS
+)
+
+# ``FileSessionClient`` method names for each ``FILE_SESSION_COMMANDS`` entry.
+# ``session_list_file_locks`` is also used by ``assert_session_exists``.
+FILE_SESSION_FACADE_METHODS: Dict[str, str] = {
+    "session_create": "create_session",
+    "session_validate": "validate_session",
+    "session_delete": "delete_session",
+    "session_list": "list_sessions",
+    "session_view": "view_session",
+    "session_open_file": "lock_file",
+    "session_close_file": "unlock_file",
+    "session_list_file_locks": "list_file_locks",
+    "subordinate_session_create": "create_subordinate_session",
+    "subordinate_session_get": "get_subordinate_session",
+    "subordinate_session_update": "update_subordinate_session",
+    "subordinate_session_delete": "delete_subordinate_session",
+    "subordinate_session_list": "list_subordinate_sessions",
+}
+
+# Transfer / advisory-lock commands may map to more than one façade method.
+TRANSFER_FACADE_METHODS: Dict[str, Tuple[str, ...]] = {
+    "project_file_transfer_download_begin": ("download",),
+    "project_file_transfer_upload_save": ("upload", "upload_new"),
+    "project_file_advisory_lock_batch": (
+        "lock_files_advisory",
+        "unlock_files_advisory",
+    ),
+}
+
+
+def assert_file_session_facade_complete() -> None:
+    """Raise ``AssertionError`` if ``FILE_SESSION_FACADE_METHODS`` is incomplete."""
+    missing_cmds = FILE_SESSION_COMMANDS - set(FILE_SESSION_FACADE_METHODS)
+    extra_cmds = set(FILE_SESSION_FACADE_METHODS) - FILE_SESSION_COMMANDS
+    if missing_cmds or extra_cmds:
+        raise AssertionError(
+            "FILE_SESSION_FACADE_METHODS out of sync with FILE_SESSION_COMMANDS: "
+            f"missing={sorted(missing_cmds)!r} extra={sorted(extra_cmds)!r}"
+        )
+    from code_analysis_client.file_session import FileSessionClient
+
+    for command, method_name in FILE_SESSION_FACADE_METHODS.items():
+        if not hasattr(FileSessionClient, method_name):
+            raise AssertionError(
+                f"FileSessionClient missing method {method_name!r} for command {command!r}"
+            )
+
+
+def assert_transfer_facade_complete() -> None:
+    """Raise ``AssertionError`` if ``TRANSFER_FACADE_METHODS`` is incomplete."""
+    missing_cmds = TRANSFER_AND_LOCK_COMMANDS - set(TRANSFER_FACADE_METHODS)
+    extra_cmds = set(TRANSFER_FACADE_METHODS) - TRANSFER_AND_LOCK_COMMANDS
+    if missing_cmds or extra_cmds:
+        raise AssertionError(
+            "TRANSFER_FACADE_METHODS out of sync with TRANSFER_AND_LOCK_COMMANDS: "
+            f"missing={sorted(missing_cmds)!r} extra={sorted(extra_cmds)!r}"
+        )
+    from code_analysis_client.file_session import FileSessionClient
+
+    for command, method_names in TRANSFER_FACADE_METHODS.items():
+        for method_name in method_names:
+            if not hasattr(FileSessionClient, method_name):
+                raise AssertionError(
+                    f"FileSessionClient missing method {method_name!r} "
+                    f"for command {command!r}"
+                )
+
+
+def _command_registered(get_command: Callable[[str], object], name: str) -> bool:
+    """Return True when ``get_command`` can resolve a command name."""
+    try:
+        get_command(name)
+        return True
+    except KeyError:
+        return False
+
+
+def assert_facade_commands_registered(get_command: Callable[[str], object]) -> None:
+    """Raise ``KeyError`` if any facade command is missing from the server registry."""
+    missing = [
+        name
+        for name in sorted(CLIENT_FACADE_COMMANDS)
+        if not _command_registered(get_command, name)
+    ]
+    if missing:
+        raise KeyError(f"Client facade commands not registered on server: {missing}")
+
+
+def assert_removed_commands_absent(get_command: Callable[[str], object]) -> None:
+    """Raise ``AssertionError`` if a removed command is still registered."""
+    present = [
+        name
+        for name in sorted(REMOVED_COMMANDS)
+        if _command_registered(get_command, name)
+    ]
+    if present:
+        raise AssertionError(f"Removed commands still registered: {present}")
+
+
+def assert_file_content_read_commands_registered(
+    get_command: Callable[[str], object],
+) -> None:
+    """Raise ``KeyError`` if a read-only content command is missing from the registry."""
+    missing = [
+        name
+        for name in sorted(FILE_CONTENT_READ_COMMANDS)
+        if not _command_registered(get_command, name)
+    ]
+    if missing:
+        raise KeyError(f"File content read commands not registered: {missing}")
+
+
+def assert_fs_commands_registered(get_command: Callable[[str], object]) -> None:
+    """Raise ``KeyError`` if a filesystem helper command is missing from the registry."""
+    missing = [
+        name
+        for name in sorted(FS_COMMANDS)
+        if not _command_registered(get_command, name)
+    ]
+    if missing:
+        raise KeyError(f"Filesystem commands not registered: {missing}")

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/universal_file.py

@@ -20,11 +20,16 @@ if TYPE_CHECKING:
 
 
 class UniversalFileClient:
-    """Edit-session workflow for project files (open → edit → write → close)."""
+    """Edit-session workflow for project files (open → edit → write → close).
+
+    Uses ``session_id`` from ``universal_file_open`` only. Not related to
+    client ``session_*`` commands (``session_create``, ``session_open_file``, …).
+    """
 
     __slots__ = ("_client",)
 
     def __init__(self, client: CodeAnalysisAsyncClient) -> None:
+        """Store the async client used for universal file workflow commands."""
         self._client = client
 
     async def open(
@@ -35,7 +40,10 @@ class UniversalFileClient:
         create: bool = False,
         initial_content: Optional[str] = None,
     ) -> Dict[str, Any]:
-        """Start an edit session (``universal_file_open``)."""
+        """Start an edit session (``universal_file_open``).
+
+        Identifies the file by ``project_id`` + ``file_path`` (not ``file_id``).
+        """
         params: Dict[str, Any] = {
             "project_id": project_id,
             "file_path": file_path,
@@ -72,7 +80,12 @@ class UniversalFileClient:
         *,
         write_mode: str = "commit",
     ) -> Dict[str, Any]:
-        """Persist or preview draft (``universal_file_write``)."""
+        """Persist or preview draft (``universal_file_write``).
+
+        Default ``write_mode`` is ``commit`` in this client wrapper. The server
+        default when the parameter is omitted is ``preview``. Pass
+        ``write_mode='preview'`` first to inspect the diff, then ``commit``.
+        """
         return unwrap_command_result(
             await self._client.call_validated(
                 "universal_file_write",
@@ -89,7 +102,7 @@ class UniversalFileClient:
         project_id: str,
         session_id: str,
     ) -> Dict[str, Any]:
-        """End edit session (``universal_file_close``)."""
+        """End edit session (``universal_file_open`` session_id, not client ``session_*``)."""
         return unwrap_command_result(
             await self._client.call_validated(
                 "universal_file_close",

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client/validation.py

@@ -13,12 +13,9 @@ from code_analysis_client.exceptions import ClientValidationError
 
 
 def prepare_params_for_schema(
-    params: Dict[str, Any], schema: Dict[str, Any]
+    params: Dict[str, Any], schema: Dict[str, Any]  # noqa: ARG001
 ) -> 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 a shallow copy of params for validation and dispatch."""
     return dict(params)
 
 
@@ -34,7 +31,7 @@ def validate_params_against_schema(
             field="params",
         )
     props = schema.get("properties") or {}
-    additional_ok = schema.get("additionalProperties", True)
+    additional_ok = schema.get("additionalProperties", False)
     required_set = set(schema.get("required") or [])
     for key, value in params.items():
         if key not in props:

code_analysis_client-1.6.39/code_analysis_client/version.txt

@@ -0,0 +1 @@
+1.6.39

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client.egg-info/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: code-analysis-client
-Version: 1.0.6
+Version: 1.6.39
 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.13
+Requires-Dist: mcp-proxy-adapter>=8.10.15
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
@@ -97,8 +97,8 @@ Sync checks (in-process registry):
 pytest tests/test_client_server_api_sync.py tests/test_code_analysis_client.py -k session
 ```
 
-Package version is in ``client/code_analysis_client/version.txt`` (synced with the
-root ``code-analysis`` project via ``scripts/sync_code_analysis_client_version.py``).
+Package version is in the root ``pyproject.toml``; before a client wheel build run
+``python scripts/sync_code_analysis_client_version.py`` (also done by ``release_build.sh``).
 
 ## Examples (this repository)
 

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/code_analysis_client.egg-info/requires.txt

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

{code_analysis_client-1.0.6 → code_analysis_client-1.6.39}/pyproject.toml

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

code_analysis_client-1.0.6/code_analysis_client/server_api.py

@@ -1,154 +0,0 @@
-"""
-Canonical command names for the high-level client API vs the live server registry.
-
-The generic client (:class:`CodeAnalysisAsyncClient.call`) can invoke any command
-returned by server ``help``. Facade modules (:mod:`file_session`, :mod:`universal_file`)
-must only reference commands listed here — and every name in
-:data:`CLIENT_FACADE_COMMANDS` must be registered on the server.
-
-Author: Vasiliy Zdanovskiy
-email: vasilyvz@gmail.com
-"""
-
-from __future__ import annotations
-
-from typing import Callable, Dict, FrozenSet
-
-# Removed from the public server surface — do not use in client facades or docs.
-LEGACY_REMOVED_COMMANDS: FrozenSet[str] = frozenset(
-    {
-        "universal_file_read",
-        "universal_file_save",
-        "universal_file_replace",
-        "universal_file_delete",
-        "read_project_text_file",
-        "write_project_text_lines",
-        "create_text_file",
-        "replace_file_lines",
-    }
-)
-
-# CST tree MCP workflow — modules may exist in the repo but commands are not registered.
-CST_REMOVED_COMMANDS: FrozenSet[str] = frozenset(
-    {
-        "cst_load_file",
-        "cst_save_tree",
-        "cst_modify_tree",
-        "cst_create_file",
-        "cst_find_node",
-        "cst_get_node_info",
-        "cst_get_node_by_range",
-        "cst_get_node_at_line",
-        "cst_reload_tree",
-        "cst_convert_and_save",
-        "list_cst_blocks",
-        "query_cst",
-        "get_file_lines",
-    }
-)
-
-REMOVED_COMMANDS: FrozenSet[str] = LEGACY_REMOVED_COMMANDS | CST_REMOVED_COMMANDS
-
-FILE_SESSION_COMMANDS: FrozenSet[str] = frozenset(
-    {
-        "session_create",
-        "session_delete",
-        "session_list",
-        "session_view",
-        "session_open_file",
-        "session_close_file",
-        "session_list_file_locks",
-        "subordinate_session_create",
-        "subordinate_session_get",
-        "subordinate_session_update",
-        "subordinate_session_delete",
-        "subordinate_session_list",
-    }
-)
-
-TRANSFER_AND_LOCK_COMMANDS: FrozenSet[str] = frozenset(
-    {
-        "project_file_transfer_download_begin",
-        "project_file_transfer_upload_save",
-        "project_file_advisory_lock_batch",
-    }
-)
-
-UNIVERSAL_FILE_COMMANDS: FrozenSet[str] = frozenset(
-    {
-        "universal_file_open",
-        "universal_file_edit",
-        "universal_file_write",
-        "universal_file_close",
-        "universal_file_preview",
-    }
-)
-
-CLIENT_FACADE_COMMANDS: FrozenSet[str] = (
-    FILE_SESSION_COMMANDS | TRANSFER_AND_LOCK_COMMANDS | UNIVERSAL_FILE_COMMANDS
-)
-
-# ``FileSessionClient`` method names for each ``FILE_SESSION_COMMANDS`` entry.
-# ``session_list_file_locks`` is also used by ``assert_session_exists``.
-FILE_SESSION_FACADE_METHODS: Dict[str, str] = {
-    "session_create": "create_session",
-    "session_delete": "delete_session",
-    "session_list": "list_sessions",
-    "session_view": "view_session",
-    "session_open_file": "lock_file",
-    "session_close_file": "unlock_file",
-    "session_list_file_locks": "list_file_locks",
-    "subordinate_session_create": "create_subordinate_session",
-    "subordinate_session_get": "get_subordinate_session",
-    "subordinate_session_update": "update_subordinate_session",
-    "subordinate_session_delete": "delete_subordinate_session",
-    "subordinate_session_list": "list_subordinate_sessions",
-}
-
-
-def assert_file_session_facade_complete() -> None:
-    """Raise ``AssertionError`` if ``FILE_SESSION_FACADE_METHODS`` is incomplete."""
-    missing_cmds = FILE_SESSION_COMMANDS - set(FILE_SESSION_FACADE_METHODS)
-    extra_cmds = set(FILE_SESSION_FACADE_METHODS) - FILE_SESSION_COMMANDS
-    if missing_cmds or extra_cmds:
-        raise AssertionError(
-            "FILE_SESSION_FACADE_METHODS out of sync with FILE_SESSION_COMMANDS: "
-            f"missing={sorted(missing_cmds)!r} extra={sorted(extra_cmds)!r}"
-        )
-    from code_analysis_client.file_session import FileSessionClient
-
-    for command, method_name in FILE_SESSION_FACADE_METHODS.items():
-        if not hasattr(FileSessionClient, method_name):
-            raise AssertionError(
-                f"FileSessionClient missing method {method_name!r} for command {command!r}"
-            )
-
-
-def _command_registered(get_command: Callable[[str], object], name: str) -> bool:
-    try:
-        get_command(name)
-        return True
-    except KeyError:
-        return False
-
-
-def assert_facade_commands_registered(get_command: Callable[[str], object]) -> None:
-    """Raise ``KeyError`` if any facade command is missing from the server registry."""
-    missing = [
-        name
-        for name in sorted(CLIENT_FACADE_COMMANDS)
-        if not _command_registered(get_command, name)
-    ]
-    if missing:
-        raise KeyError(f"Client facade commands not registered on server: {missing}")
-
-
-def assert_removed_commands_absent(get_command: Callable[[str], object]) -> None:
-    """Raise ``AssertionError`` if a removed command is still registered."""
-    present = [
-        name
-        for name in sorted(REMOVED_COMMANDS)
-        if _command_registered(get_command, name)
-    ]
-    if present:
-        raise AssertionError(f"Removed commands still registered: {present}")

code_analysis_client-1.0.6/code_analysis_client/version.txt

@@ -1 +0,0 @@
-1.0.6