Finish migration of diagnostics to usage of API server

Author: Aksem

docs/api-protocol.md

@@ -333,6 +333,7 @@ Execute an action with streaming partial results. The server sends
   "params": {"file_paths": ["/path/to/file.py"]},
   "partial_result_token": "diag_1",
   "options": {
+    "result_formats": ["json", "string"],
     "trigger": "system",
     "dev_env": "ide"
   }
@@ -341,10 +342,20 @@ Execute an action with streaming partial results. The server sends
 
 Required: `action`, `project`, `partial_result_token`.
 
+Supported `result_formats`: `"json"`, `"string"`, etc. (same as `actions/run`).
+
 **Result:** Same as `actions/run` (the final aggregated result).
 
 During execution, the server sends `actions/partialResult` notifications (see below).
 
+> **Guarantee:** The API 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
+> before returning the aggregated response.  Clients can therefore rely solely on
+> `actions/partialResult` notifications to receive results and safely ignore the
+> response body of this request.
+
 ---
 
 #### `actions/reload`
@@ -513,11 +524,23 @@ Sent during `actions/runWithPartialResults` execution as results stream in.
 **Params:**
 
 ```json
-{"token": "diag_1", "value": {"messages": {"file.py": [...]}}}
+{
+  "token": "diag_1",
+  "value": {
+    "result_by_format": {
+      "json": {"messages": {"file.py": [...]}},
+      "string": "3 issues found in file.py"
+    }
+  }
+}
 ```
 
 `token` matches the `partial_result_token` from the originating request.
 
+`result_by_format` contains results in all formats requested in the originating
+`actions/runWithPartialResults` params (same structure as `actions/run` response,
+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.

extensions/fine_python_flake8/fine_python_flake8/action.py

@@ -25,9 +25,9 @@ def map_flake8_check_result_to_lint_message(result: tuple) -> lint_files_action.
     error_code, line_number, column, text, physical_line = result
     return lint_files_action.LintMessage(
         range=lint_files_action.Range(
-            start=lint_files_action.Position(line=line_number, character=column),
+            start=lint_files_action.Position(line=line_number - 1, character=column),
             end=lint_files_action.Position(
-                line=line_number,
+                line=line_number - 1,
                 character=len(physical_line) if physical_line is not None else column,
             ),
         ),

extensions/fine_python_mypy/fine_python_mypy/output_parser.py

@@ -18,7 +18,7 @@
 ERROR_CODE_BASE_URL = "https://mypy.readthedocs.io/en/latest/_refs.html#code-"
 SEE_HREF_PREFIX = "See https://mypy.readthedocs.io"
 SEE_PREFIX_LEN = len("See ")
-LINE_OFFSET = 0
+LINE_OFFSET = 1
 CHAR_OFFSET = 1
 NOTE_CODE = "note"
 

extensions/fine_python_pyrefly/fine_python_pyrefly/lint_files_handler.py

@@ -217,8 +217,8 @@ def map_pyrefly_error_to_lint_message(error: dict) -> lint_files_action.LintMess
 
     return lint_files_action.LintMessage(
         range=lint_files_action.Range(
-            start=lint_files_action.Position(line=start_line, character=start_column),
-            end=lint_files_action.Position(line=end_line, character=end_column),
+            start=lint_files_action.Position(line=start_line - 1, character=start_column),
+            end=lint_files_action.Position(line=end_line - 1, character=end_column),
         ),
         message=error.get("description", ""),
         code=error_code,

extensions/fine_python_ruff/fine_python_ruff/lint_files_handler.py

@@ -201,8 +201,8 @@ def map_ruff_violation_to_lint_message(
 
     return lint_files_action.LintMessage(
         range=lint_files_action.Range(
-            start=lint_files_action.Position(line=start_line, character=start_column),
-            end=lint_files_action.Position(line=end_line, character=end_column),
+            start=lint_files_action.Position(line=start_line - 1, character=start_column),
+            end=lint_files_action.Position(line=end_line - 1, character=end_column),
         ),
         message=violation.get("message", ""),
         code=code,

finecode_extension_api/src/finecode_extension_api/actions/lint_files.py

@@ -8,6 +8,24 @@
 
 @dataclasses.dataclass
 class Position:
+    """A position in a text document.
+
+    Both ``line`` and ``character`` are **0-based**, matching the LSP specification:
+    - ``line``: 0-based line index (line 0 = first line of the file).
+    - ``character``: 0-based UTF-16 code unit offset within the line.
+
+    Extension authors note: most CLI linters (ruff, mypy, flake8) report 1-based line
+    numbers in their output. You must subtract 1 when building a ``Position`` from such
+    output::
+
+        # ruff JSON: location["row"] is 1-based
+        Position(line=location["row"] - 1, character=location["column"])
+
+    Extensions that receive diagnostics from an embedded LSP server (via
+    ``map_diagnostics_to_lint_messages``) get 0-based values directly from the LSP
+    protocol — do NOT subtract 1 in that case.
+    """
+
     line: int
     character: int
 
@@ -91,8 +109,8 @@ def to_text(self) -> str | textstyler.StyledText:
                     if message.source is not None:
                         source_str = f" ({message.source})"
                     text.append_styled(file_path_str, bold=True)
-                    text.append(f":{message.range.start.line}")
-                    text.append(f":{message.range.start.character}: ")
+                    text.append(f":{message.range.start.line + 1}")
+                    text.append(f":{message.range.start.character + 1}: ")
                     if message.code is not None:
                         text.append_styled(
                             message.code, foreground=textstyler.Color.RED

finecode_extension_runner/src/finecode_extension_runner/_services/merge_results.py

@@ -0,0 +1,52 @@
+import dataclasses
+
+from loguru import logger
+from pydantic.dataclasses import dataclass as pydantic_dataclass
+
+from finecode_extension_api import code_action
+from finecode_extension_runner import global_state, run_utils
+
+
+async def merge_results(action_name: str, results: list[dict]) -> dict:
+    """Merge multiple serialized action results into one using the action's result type.
+
+    Each entry in ``results`` must be a dict produced by ``dataclasses.asdict()``
+    of the action's ``RESULT_TYPE``.  Merging is delegated to
+    ``RunActionResult.update()``, the same mechanism the runner uses when
+    combining results from multiple handlers within a single run.
+    """
+    if global_state.runner_context is None:
+        raise ValueError("Extension runner is not initialized yet")
+
+    # Prefer cached result_type to avoid re-importing the action module.
+    action_cache = global_state.runner_context.action_cache_by_name.get(action_name)
+    if action_cache is not None and action_cache.exec_info is not None:
+        result_type = action_cache.exec_info.result_type
+    else:
+        # Cold cache: action hasn't been run yet in this runner; import the type.
+        try:
+            action = global_state.runner_context.project.actions[action_name]
+        except KeyError:
+            raise ValueError(f"Action '{action_name}' not found")
+        action_type = run_utils.import_module_member_by_source_str(action.source)
+        result_type = action_type.RESULT_TYPE
+
+    non_empty = [r for r in results if r]
+    if result_type is None or not non_empty:
+        return {}
+
+    result_type_pydantic = pydantic_dataclass(result_type)
+
+    merged: code_action.RunActionResult | None = None
+    for result_dict in non_empty:
+        typed = result_type_pydantic(**result_dict)
+        if merged is None:
+            merged = typed
+        else:
+            merged.update(typed)
+
+    if merged is None:
+        return {}
+
+    logger.trace(f"merge_results: merged {len(non_empty)} results for action '{action_name}'")
+    return dataclasses.asdict(merged)

finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py

@@ -76,7 +76,7 @@ async def run_action(
         last_run_id += 1
 
     logger.trace(
-        f"Run action '{action_def.name}', run id: {run_id}, partial result token: {partial_result_token}"
+        f"run_action: action='{action_def.name}', run_id={run_id}, partial_result_token={partial_result_token}"
     )
 
     # TODO: check whether config is set: this will be solved by passing initial
@@ -144,6 +144,7 @@ async def run_action(
 
     try:
         send_partial_results = partial_result_token is not None
+        logger.trace(f"R{run_id} | send_partial_results={send_partial_results}, partial_result_token={partial_result_token}, payload_type={type(payload).__name__}, is_iterable={isinstance(payload, collections.abc.AsyncIterable)}")
         with action_exec_info.process_executor.activate():
             # action payload can be iterable or not
             if isinstance(payload, collections.abc.AsyncIterable):
@@ -417,11 +418,12 @@ def create_action_exec_info(action: domain.ActionDeclaration) -> domain.ActionEx
 
     payload_type = action_type_def.PAYLOAD_TYPE
     run_context_type = action_type_def.RUN_CONTEXT_TYPE
+    result_type = action_type_def.RESULT_TYPE
 
     # TODO: validate that classes and correct subclasses?
 
     action_exec_info = domain.ActionExecInfo(
-        payload_type=payload_type, run_context_type=run_context_type
+        payload_type=payload_type, run_context_type=run_context_type, result_type=result_type
     )
     return action_exec_info
 

finecode_extension_runner/src/finecode_extension_runner/domain.py

@@ -54,11 +54,13 @@ def __init__(
         self,
         payload_type: type[code_action.RunActionPayload] | None,
         run_context_type: type[code_action.RunActionContext] | None,
+        result_type: type[code_action.RunActionResult] | None = None,
     ) -> None:
         self.payload_type: type[code_action.RunActionPayload] | None = payload_type
         self.run_context_type: type[code_action.RunActionContext] | None = (
             run_context_type
         )
+        self.result_type: type[code_action.RunActionResult] | None = result_type
         # instantiation of process executor impl is cheap. To avoid analyzing all
         # action handlers and checking whether they need process executor, just
         # instantiate here. It will be started only if handlers need it.

finecode_extension_runner/src/finecode_extension_runner/lsp_server.py

@@ -25,6 +25,7 @@
 
 from finecode_extension_runner import schemas, services
 from finecode_extension_runner._services import run_action as run_action_service
+from finecode_extension_runner._services import merge_results as merge_results_service
 from finecode_extension_runner.di import resolver
 
 import sys
@@ -258,6 +259,9 @@ def create_lsp_server() -> lsp_server.LanguageServer:
     register_resolve_package_path_cmd = server.command("packages/resolvePath")
     register_resolve_package_path_cmd(resolve_package_path)
 
+    register_merge_results_cmd = server.command("actions/mergeResults")
+    register_merge_results_cmd(merge_results_cmd)
+
     def on_process_exit():
         logger.info("Exit extension runner")
         services.shutdown_all_action_handlers()
@@ -270,8 +274,8 @@ def send_partial_result(
     ) -> None:
         partial_result_dict = dataclasses.asdict(partial_result)
         partial_result_json = json.dumps(partial_result_dict)
-        logger.debug(
-            f"Send partial result for {token}, length {len(partial_result_json)}"
+        logger.trace(
+            f"send_partial_result: token={token}, length={len(partial_result_json)}, preview={partial_result_json[:200]}"
         )
         server.progress(types.ProgressParams(token=token, value=partial_result_json))
 
@@ -526,3 +530,13 @@ async def resolve_package_path(ls: lsp_server.LanguageServer, package_name: str)
     result = services.resolve_package_path(package_name)
     logger.trace(f"Resolved {package_name} to {result}")
     return {"packagePath": result}
+
+
+async def merge_results_cmd(ls: lsp_server.LanguageServer, action_name: str, results: list):
+    logger.trace(f"Merge results: action={action_name}, count={len(results)}")
+    try:
+        merged = await merge_results_service.merge_results(action_name=action_name, results=results)
+        return {"merged": merged}
+    except Exception as exception:
+        logger.exception(f"Merge results error: {exception}")
+        return {"error": str(exception)}