Finish initial implementation of IWorkspaceActionRunner and allow to run actions in workspace sequentially

Author: Aksem

docs/wm-er-protocol.md

@@ -76,7 +76,8 @@ The protocol is LSP-shaped with a small set of custom commands.
       2. `params` (object)
       3. `options` (object, optional)
     - Options (snake_case keys are expected):
-      - `meta`: `{ "trigger": "user|system|unknown", "dev_env": "ide|cli|ai|precommit|ci" }`
+      - `meta`: `{ "trigger": "user|system|unknown", "dev_env": "ide|cli|ai|precommit|ci", "orchestration_depth": int }`
+        - `orchestration_depth`: cross-boundary hop counter, defaults to `0`. The ER propagates it unchanged via `RunActionMeta.orchestration_depth`.
       - `partial_result_token`: `int | string` (used to correlate `$/progress`)
       - `result_formats`: `["json", "string"]` (defaults to `["json"]`)
     - Result (success):
@@ -144,6 +145,24 @@ The protocol is LSP-shaped with a small set of custom commands.
   - Result: `{ "config": "<stringified JSON config>" }`
   - Used by ER during `finecodeRunner/updateConfig` to resolve project config.
 
+- `finecode/runActionInProject`
+  - Params:
+    - `actionSource` (string): import path of the action class (e.g. `"myext.actions.lint.LintAction"`)
+    - `payload` (object): serialized action payload (`dataclasses.asdict`)
+    - `meta` (object): `{ "trigger": string, "devEnv": string, "orchestrationDepth": int }`
+  - Result: `{ "result": <json result object>, "returnCode": 0|1 }`
+  - Runs the action at project scope (all env-runners of the ER's own project). WM enforces `OrchestrationPolicy.max_recursion_depth` before dispatching.
+
+- `finecode/runActionInWorkspace`
+  - Params:
+    - `actionSource` (string): import path of the action class
+    - `payload` (object): serialized action payload
+    - `meta` (object): `{ "trigger": string, "devEnv": string, "orchestrationDepth": int }`
+    - `projectPaths` (list[string] | null): explicit POSIX project paths, or `null` for all projects that declare the action
+    - `concurrently` (boolean, default `true`): run projects concurrently.
+  - Result: `{ "resultsByProject": { "<posix path>": <json result>, ... } }`
+  - Fans out the action across the specified projects (or all projects that declare it). WM enforces `OrchestrationPolicy.max_project_fanout` before dispatching.
+
 **Notifications**
 
 - `$/progress`

finecode_extension_api/src/finecode_extension_api/interfaces/iworkspaceactionrunner.py

@@ -28,4 +28,5 @@ async def run_action_in_projects(
         payload: PayloadT,
         meta: code_action.RunActionMeta,
         project_paths: list[pathlib.Path] | None = None,
+        concurrently: bool = True,
     ) -> dict[pathlib.Path, ResultT]: ...

finecode_extension_runner/pyproject.toml

@@ -14,6 +14,7 @@ dependencies = [
     "deepmerge==2.0.*",
     "debugpy==1.8.*",
     "ordered-set==4.1.*",
+    "apischema==0.19.*",
 ]
 
 [dependency-groups]

finecode_extension_runner/src/finecode_extension_runner/impls/workspace_action_runner.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
 import dataclasses
+import json
 import pathlib
 import typing
 from typing import Any, Awaitable, Callable
 
+import apischema
 from finecode_extension_api import code_action
 from finecode_extension_api.interfaces import iactionrunner, iworkspaceactionrunner
 from finecode_extension_runner import run_utils
@@ -25,6 +27,7 @@ async def run_action_in_projects(
         payload: PayloadT,
         meta: code_action.RunActionMeta,
         project_paths: list[pathlib.Path] | None = None,
+        concurrently: bool = True,
     ) -> dict[pathlib.Path, ResultT]:
         action_source: str = action.source
         action_cls = run_utils.import_module_member_by_source_str(action_source)
@@ -41,9 +44,17 @@ async def run_action_in_projects(
                 "projectPaths": [p.as_posix() for p in project_paths]
                 if project_paths is not None
                 else None,
+                "concurrently": concurrently,
             },
         )
+        # raw.resultsByProject is a stringified JSON string — pygls converts
+        # JSON-RPC responses to Object and mangles path-keyed dicts (slashes
+        # are invalid Python identifiers), so we stringify on the WM side and
+        # parse back here, following the same pattern as projects/getRawConfig.
+        results_by_project: dict = json.loads(raw.resultsByProject)
         return {
-            pathlib.Path(k): action_cls.RESULT_TYPE(**v)
-            for k, v in raw.get("resultsByProject", {}).items()
+            pathlib.Path(k): apischema.deserialize(
+                action_cls.RESULT_TYPE, next(iter(v.values()), {})
+            )
+            for k, v in results_by_project.items()
         }

src/finecode/wm_server/runner/_internal_client_types.py

@@ -1412,6 +1412,29 @@ class RunActionInWorkspaceParams:
     payload: dict
     meta: RunActionInProjectMeta
     project_paths: list[str] | None = None
+    concurrently: bool = True
+
+
+@dataclasses.dataclass
+class RunActionInWorkspaceResult(BaseResult):
+    # Stringified JSON, not a dict — same pattern as GetProjectRawConfigResult.
+    # Reason: pygls deserializes JSON-RPC responses into attribute-style Object
+    # instances. Dict keys that are POSIX paths (containing "/") are not valid
+    # Python identifiers, so pygls mangles them to "_0", "_1", etc., losing the
+    # original paths. Returning the payload as a JSON string bypasses pygls
+    # deserialization; the ER side does json.loads() to recover the real dict.
+    results_by_project: str
+
+
+@dataclasses.dataclass
+class RunActionInWorkspaceRequest(BaseRequest):
+    params: RunActionInWorkspaceParams
+    method = RUN_ACTION_IN_WORKSPACE
+
+
+@dataclasses.dataclass
+class RunActionInWorkspaceResponse(BaseResponse):
+    result: RunActionInWorkspaceResult
 
 
 @dataclasses.dataclass
@@ -1613,4 +1636,10 @@ class ExitNotification(BaseNotification):
         None,
         None,
     ),
+    RUN_ACTION_IN_WORKSPACE: (
+        RunActionInWorkspaceRequest,
+        RunActionInWorkspaceParams,
+        RunActionInWorkspaceResponse,
+        RunActionInWorkspaceResult,
+    ),
 }

src/finecode/wm_server/runner/runner_manager.py

@@ -306,18 +306,19 @@ async def handle_run_action_in_workspace(
                 run_trigger=run_trigger,
                 dev_env=dev_env,
                 orchestration_depth=params.meta.orchestration_depth,
+                concurrently=params.concurrently,
             )
         except ActionRunFailed as exc:
             raise ValueError(exc.message) from exc
-        return {
-            "resultsByProject": {
+        return _internal_client_types.RunActionInWorkspaceResult(
+            results_by_project=json.dumps({
                 k.as_posix(): {
                     action: resp.result_by_format.get("json", {})
                     for action, resp in v.items()
                 }
                 for k, v in results.items()
-            }
-        }
+            })
+        )
 
     runner.client.feature(
         _internal_client_types.RUN_ACTION_IN_WORKSPACE,