Rename API Server to WM Server

Author: Aksem

docs/cli.md

@@ -15,7 +15,7 @@ The `run` command supports two usage modes.
 
 ### Standalone (one-shot) — default
 
-Each `run` invocation is fully independent. FineCode starts a dedicated API server subprocess for the duration of the command, then shuts it down on exit. This is the default behavior.
+Each `run` invocation is fully independent. FineCode starts a dedicated WM Server subprocess for the duration of the command, then shuts it down on exit. This is the default behavior.
 
 ```bash
 python -m finecode run lint
@@ -25,7 +25,7 @@ Use this in CI/CD pipelines or any context where you don't want persistent backg
 
 ### Persistent server
 
-A long-lived API server holds warm state — loaded configuration, started runners — across multiple `run` calls. Use `--shared-server` to connect to a running shared instance instead of starting a dedicated one.
+A long-lived WM Server holds warm state — loaded configuration, started runners — across multiple `run` calls. Use `--shared-server` to connect to a running shared instance instead of starting a dedicated one.
 
 ```bash
 # Connect to the shared server (start it first if needed):
@@ -35,7 +35,7 @@ python -m finecode run --shared-server format
 
 This mode is used automatically by the LSP and MCP integrations. It gives faster repeated runs because configuration loading and runner startup are amortized across calls.
 
-The server waits 30 seconds after the last client disconnects before shutting down (configurable via `--disconnect-timeout` on `start-api-server`).
+The server waits 30 seconds after the last client disconnects before shutting down (configurable via `--disconnect-timeout` on `start-wm-server`).
 
 ---
 
@@ -54,7 +54,7 @@ python -m finecode run [options] <action> [<action> ...] [payload] [--config.<ke
 | `--workdir=<path>` | Use `<path>` as the workspace root instead of `cwd` |
 | `--project=<name>` | Run only in this project. Repeatable for multiple projects. |
 | `--concurrently` | Run actions concurrently within each project |
-| `--shared-server` | Connect to the shared persistent API server instead of starting a dedicated one |
+| `--shared-server` | Connect to the shared persistent WM Server instead of starting a dedicated one |
 | `--trace` | Enable verbose (trace-level) logging |
 | `--no-env-config` | Ignore `FINECODE_CONFIG_*` environment variables |
 | `--no-save-results` | Do not write action results to the cache directory |
@@ -163,13 +163,13 @@ python -m finecode start-lsp --stdio | --socket <port> | --ws [--host <host>] [-
 | `--trace` | Enable verbose logging |
 | `--debug` | Wait for a debugpy client on port 5680 |
 
-The LSP server connects to the **FineCode API server** on startup (starting one if needed). See [LSP and MCP Architecture](reference/lsp-mcp-architecture.md) for details.
+The LSP server connects to the **FineCode WM Server** on startup (starting one if needed). See [LSP and MCP Architecture](reference/lsp-mcp-architecture.md) for details.
 
 ---
 
 ## `start-mcp`
 
-Start the FineCode MCP server on stdio. Connects to a running FineCode API server (or starts one) and exposes FineCode tools via the Model Context Protocol.
+Start the FineCode MCP server on stdio. Connects to a running FineCode WM Server (or starts one) and exposes FineCode tools via the Model Context Protocol.
 
 ```text
 .venvs/dev_workspace/bin/python -m finecode start-mcp [--workdir=<path>] [--trace]
@@ -184,12 +184,12 @@ Typically started automatically by MCP-compatible clients (for example, Claude C
 
 ---
 
-## `start-api-server`
+## `start-wm-server`
 
-Start the FineCode API server standalone (TCP JSON-RPC), listen for client connections. Shuts down after the last client disconnects and the disconnect timeout expires.
+Start the FineCode Workspace Manager Server standalone (TCP JSON-RPC), listen for client connections. Shuts down after the last client disconnects and the disconnect timeout expires.
 
 ```text
-python -m finecode start-api-server [--trace] [--disconnect-timeout=<seconds>]
+python -m finecode start-wm-server [--trace] [--disconnect-timeout=<seconds>]
 ```
 
 | Option | Description |

docs/development.md

@@ -25,7 +25,7 @@ The FineCode documentation is organized into the following sections:
 
 ### Developer Documentation
 - **Overview** (`development.md`): Contributing to FineCode core development
-- **API Protocol** (`api-protocol.md`): Technical protocol and endpoint reference
+- **WM Protocol** (`wm-protocol.md`): Technical protocol and endpoint reference
 - **Developing FineCode** (`guides/developing-finecode.md`): Monorepo workflows and conventions
 
 ### Potential Additions

docs/reference/lsp-mcp-architecture.md

@@ -1,22 +1,22 @@
 # LSP and MCP Architecture
 
-FineCode uses one shared API server for CLI, IDE (LSP), and AI-agent (MCP) clients.
+FineCode uses one shared Workspace Manager Server (WM Server) for CLI, IDE (LSP), and AI-agent (MCP) clients.
 
 ## Component model
 
 ```text
-FineCode API Server (TCP JSON-RPC, auto-managed)
+FineCode WM Server (TCP JSON-RPC, auto-managed)
 ├── WorkspaceContext, runners, services
 └── auto-stops when no clients remain
 
 LSP Server (start-lsp, started by IDE)
-└── connects to API server (starts one if needed)
+└── connects to WM Server (starts one if needed)
 
 MCP Server (start-mcp, started by MCP client)
-└── connects to API server (starts one if needed)
+└── connects to WM Server (starts one if needed)
 ```
 
-The API server writes its port to `.venvs/dev_workspace/cache/finecode/api_port` for client discovery.
+The WM Server writes its port to `.venvs/dev_workspace/cache/finecode/wm_port` for client discovery.
 
 ## LSP request flow
 
@@ -41,9 +41,9 @@ The LSP layer translates protocol messages into FineCode actions, delegates exec
 
 ## Lifecycle behavior
 
-- Any client (CLI, LSP, MCP) can start the API server if it is not already running.
-- Each connected client keeps the API server alive.
-- When the last client disconnects, the API server exits automatically.
+- Any client (CLI, LSP, MCP) can start the WM Server if it is not already running.
+- Each connected client keeps the WM Server alive.
+- When the last client disconnects, the WM Server exits automatically.
 
 ## Manual server startup for debugging
 

docs/api-protocol.md docs/wm-protocol.mddocs/api-protocol.md renamed to docs/wm-protocol.md

@@ -1,15 +1,15 @@
-# FineCode API Server Protocol
+# FineCode WM Server Protocol
 
-The FineCode API server is a TCP JSON-RPC 2.0 service that manages the workspace state
+The FineCode Workspace Manager Server (WM Server) is a TCP JSON-RPC 2.0 service that manages the workspace state
 (projects, configs, extension runners). Any client — LSP server, MCP server, or CLI — can
 connect to it.
 
 ## Transport
 
 - TCP on `127.0.0.1`, random free port
 - Content-Length framing (same as LSP): `Content-Length: N\r\n\r\n{json_body}`
-- Discovery: port written to `.venvs/dev_workspace/cache/finecode/api_port`
-- Auto-stops when the last client disconnects (after a 5s grace period) or if no client connects 30 seconds after start of API Server
+- Discovery: port written to `.venvs/dev_workspace/cache/finecode/wm_port`
+- Auto-stops when the last client disconnects (after a 5s grace period) or if no client connects 30 seconds after start of WM Server
 
 ## JSON-RPC 2.0
 
@@ -89,7 +89,7 @@ list all projects and perform path comparisons itself.
 ```
 
 The server internally calls
-:func:`finecode.api_server.services.run_service.find_action_project` with
+:func:`finecode.wm_server.services.run_service.find_action_project` with
 ``action_name="lint"`` and returns the corresponding project name.
 
 ---
@@ -102,7 +102,7 @@ and optionally starts extension runners.
 > **Design note:** Ideally, workspace directories would be a single shared
 > definition independent of which client connects (LSP, MCP, CLI). Currently,
 > each client calls `workspace/addDir` with its own working directory, so the
-> API server's workspace is the union of what clients have registered. This is a
+> WM Server's workspace is the union of what clients have registered. This is a
 > known simplification — a future improvement would introduce a workspace
 > configuration file or a dedicated workspace management layer so that the set
 > of directories is not environment-specific.
@@ -455,7 +455,7 @@ Supported `result_formats`: `"json"`, `"string"`, etc. (same as `actions/run`).
 
 During execution, the server sends `actions/partialResult` notifications (see below).
 
-> **Guarantee:** The API server always delivers results via `actions/partialResult`
+> **Guarantee:** The WM Server always delivers results via `actions/partialResult`
 > notifications, even when an extension runner does not stream incrementally (i.e.
 > it collects all results internally and returns them as a single final response).
 > In that case the server emits the final result as a partial result notification
@@ -485,7 +485,7 @@ Hot-reload handler code for an action without restarting runners.
 
 ### `documents/` — Document Sync
 
-Notifications from the LSP client to keep the API server (and extension runners)
+Notifications from the LSP client to keep the WM Server (and extension runners)
 informed about open documents. These are fire-and-forget (no response).
 
 #### `documents/opened`
@@ -645,7 +645,7 @@ environment, it is stopped first.
 
 #### `server/shutdown`
 
-Explicitly shut down the API server.
+Explicitly shut down the WM Server.
 
 - **Type:** request
 - **Clients:** any
@@ -659,7 +659,7 @@ Explicitly shut down the API server.
 
 ### Server -> Client Notifications
 
-These are sent by the API server to connected clients. Clients must implement
+These are sent by the WM Server to connected clients. Clients must implement
 a background reader to receive them.
 
 #### `actions/partialResult`
@@ -692,7 +692,7 @@ but without `return_code`).
 
 > **Note:** Notifications are delivered only to the client connection that
 > initiated the corresponding `actions/runWithPartialResults` request.  The
-> API server does **not** broadcast these messages to every connected client.
+> WM Server does **not** broadcast these messages to every connected client.
 
 ---
 

src/finecode/cli.py

@@ -12,7 +12,7 @@
 from finecode import logger_utils, user_messages
 from finecode.lsp_server import communication_utils
 from finecode.cli_app.commands import dump_config_cmd, prepare_envs_cmd, run_cmd
-from finecode.api_server.config.config_models import ConfigurationError
+from finecode.wm_server.config.config_models import ConfigurationError
 
 
 FINECODE_CONFIG_ENV_PREFIX = "FINECODE_CONFIG_"
@@ -461,7 +461,7 @@ def dump_config(trace: bool, debug: bool, project: str | None, shared_server: bo
 @click.option("--workdir", "workdir", default=None, type=str, help="Workspace root directory")
 @click.option("--trace", "trace", is_flag=True, default=False)
 def start_mcp(workdir: str | None, trace: bool):
-    """Start the FineCode MCP server (stdio). Connects to a running FineCode API server."""
+    """Start the FineCode MCP server (stdio). Connects to a running FineCode WM Server."""
     from finecode import mcp_server
 
     logger_utils.init_logger(log_name="mcp_server", trace=trace, stdout=False)
@@ -487,13 +487,13 @@ def start_mcp(workdir: str | None, trace: bool):
     show_default=True,
     help="Seconds to wait after the last client disconnects before shutting down.",
 )
-def start_api_server(trace: bool, port_file: str | None, disconnect_timeout: int):
-    """Start the FineCode API server standalone (TCP JSON-RPC). Auto-stops when all clients disconnect."""
-    from finecode.api_server import api_server
+def start_wm_server(trace: bool, port_file: str | None, disconnect_timeout: int):
+    """Start the FineCode WM Server standalone (TCP JSON-RPC). Auto-stops when all clients disconnect."""
+    from finecode.wm_server import wm_server
 
-    logger_utils.init_logger(log_name="api_server", trace=trace, stdout=False)
+    logger_utils.init_logger(log_name="wm_server", trace=trace, stdout=False)
     port_file_path = pathlib.Path(port_file) if port_file else None
-    asyncio.run(api_server.start_standalone(port_file=port_file_path, disconnect_timeout=disconnect_timeout))
+    asyncio.run(wm_server.start_standalone(port_file=port_file_path, disconnect_timeout=disconnect_timeout))
 
 
 if __name__ == "__main__":

src/finecode/cli_app/commands/dump_config_cmd.py

@@ -1,7 +1,7 @@
 import pathlib
 
-from finecode.api_client import ApiClient, ApiError
-from finecode.api_server import api_server
+from finecode.wm_client import ApiClient, ApiError
+from finecode.wm_server import wm_server
 
 
 class DumpFailed(Exception):
@@ -15,15 +15,15 @@ async def dump_config(
     port_file = None
     try:
         if own_server:
-            port_file = api_server.start_own_server(workdir_path)
+            port_file = wm_server.start_own_server(workdir_path)
             try:
-                port = await api_server.wait_until_ready_from_file(port_file)
+                port = await wm_server.wait_until_ready_from_file(port_file)
             except TimeoutError as exc:
                 raise DumpFailed(str(exc)) from exc
         else:
-            api_server.ensure_running(workdir_path)
+            wm_server.ensure_running(workdir_path)
             try:
-                port = await api_server.wait_until_ready()
+                port = await wm_server.wait_until_ready()
             except TimeoutError as exc:
                 raise DumpFailed(str(exc)) from exc
 

src/finecode/cli_app/commands/prepare_envs_cmd.py

@@ -2,8 +2,8 @@
 
 from loguru import logger
 
-from finecode.api_client import ApiClient, ApiError
-from finecode.api_server import api_server
+from finecode.wm_client import ApiClient, ApiError
+from finecode.wm_server import wm_server
 
 
 class PrepareEnvsFailed(Exception):
@@ -27,15 +27,15 @@ async def prepare_envs(
     port_file = None
     try:
         if own_server:
-            port_file = api_server.start_own_server(workdir_path)
+            port_file = wm_server.start_own_server(workdir_path)
             try:
-                port = await api_server.wait_until_ready_from_file(port_file)
+                port = await wm_server.wait_until_ready_from_file(port_file)
             except TimeoutError as exc:
                 raise PrepareEnvsFailed(str(exc)) from exc
         else:
-            api_server.ensure_running(workdir_path)
+            wm_server.ensure_running(workdir_path)
             try:
-                port = await api_server.wait_until_ready()
+                port = await wm_server.wait_until_ready()
             except TimeoutError as exc:
                 raise PrepareEnvsFailed(str(exc)) from exc
 

src/finecode/cli_app/commands/run_cmd.py

@@ -5,9 +5,9 @@
 
 import click
 
-from finecode.api_client import ApiClient, ApiError
-from finecode.api_server import api_server
-from finecode.api_server.runner import runner_client
+from finecode.wm_client import ApiClient, ApiError
+from finecode.wm_server import wm_server
+from finecode.wm_server.runner import runner_client
 from finecode.cli_app import utils
 
 
@@ -30,15 +30,15 @@ async def run_actions(
     port_file = None
     try:
         if own_server:
-            port_file = api_server.start_own_server(workdir_path)
+            port_file = wm_server.start_own_server(workdir_path)
             try:
-                port = await api_server.wait_until_ready_from_file(port_file)
+                port = await wm_server.wait_until_ready_from_file(port_file)
             except TimeoutError as exc:
                 raise RunFailed(str(exc)) from exc
         else:
-            api_server.ensure_running(workdir_path)
+            wm_server.ensure_running(workdir_path)
             try:
-                port = await api_server.wait_until_ready()
+                port = await wm_server.wait_until_ready()
             except TimeoutError as exc:
                 raise RunFailed(str(exc)) from exc
 

src/finecode/cli_app/utils.py

@@ -3,9 +3,9 @@
 
 import click
 
-from finecode.api_server import context
-from finecode.api_server.runner import runner_client
-from finecode.api_server.services import run_service
+from finecode.wm_server import context
+from finecode.wm_server.runner import runner_client
+from finecode.wm_server.services import run_service
 
 
 class RunActionsResult(typing.NamedTuple):

src/finecode/lsp_server/__init__.py

@@ -1,3 +1,3 @@
 """
-- all LSP handlers must wait on API Server start (e.g. `await global_state.server_initialized.wait()`)
+- all LSP handlers must wait on WM server start (e.g. `await global_state.server_initialized.wait()`)
 """