Finish progress reporting. Split wm_server module in multiple modules.

Author: Aksem

finecode_builtin_handlers/src/finecode_builtin_handlers/lint.py

@@ -74,9 +74,15 @@ async def run(
         lint_files_action_instance = self.action_runner.get_action_by_source(
             lint_files_action.LintFilesAction
         )
-        async for partial in self.action_runner.run_action_iter(
-            action=lint_files_action_instance,
-            payload=lint_files_action.LintFilesRunPayload(file_paths=file_uris),
-            meta=run_meta,
-        ):
-            yield lint_action.LintRunResult(messages=partial.messages)
+        async with run_context.progress("Linting files", total=len(file_uris)) as progress:
+            async for partial in self.action_runner.run_action_iter(
+                action=lint_files_action_instance,
+                payload=lint_files_action.LintFilesRunPayload(file_paths=file_uris),
+                meta=run_meta,
+            ):
+                uris = list(partial.messages)
+                msg = str(uris[0]) if uris else None
+                if len(uris) > 1:
+                    msg += f" and {len(uris) - 1} related"
+                await progress.advance(message=msg)
+                yield lint_action.LintRunResult(messages=partial.messages)

finecode_extension_api/src/finecode_extension_api/code_action.py

@@ -94,14 +94,109 @@ class PartialResultSender(typing.Protocol):
     async def send(self, result: RunActionResult) -> None: ...
 
 
-class _NoOpPartialResultSender:
+class _NoOpPartialResultSender(PartialResultSender):
     async def send(self, result: RunActionResult) -> None:
         pass
 
 
 _NOOP_SENDER = _NoOpPartialResultSender()
 
 
+class ProgressSender(typing.Protocol):
+    """Framework-internal interface for sending progress notifications."""
+
+    async def begin(
+        self,
+        title: str,
+        message: str | None = None,
+        percentage: int | None = None,
+        cancellable: bool = False,
+        total: int | None = None,
+    ) -> None: ...
+
+    async def report(
+        self,
+        message: str | None = None,
+        percentage: int | None = None,
+    ) -> None: ...
+
+    async def end(self, message: str | None = None) -> None: ...
+
+
+class _NoOpProgressSender(ProgressSender):
+    async def begin(
+        self,
+        title: str,
+        message: str | None = None,
+        percentage: int | None = None,
+        cancellable: bool = False,
+        total: int | None = None,
+    ) -> None:
+        pass
+
+    async def report(
+        self,
+        message: str | None = None,
+        percentage: int | None = None,
+    ) -> None:
+        pass
+
+    async def end(self, message: str | None = None) -> None:
+        pass
+
+
+_NOOP_PROGRESS_SENDER = _NoOpProgressSender()
+
+
+class ProgressContext:
+    """Async context manager for reporting progress from handlers.
+
+    Two methods serve different use cases:
+    - ``advance(steps, message)`` — the common "N of M" pattern; auto-calculates percentage.
+    - ``report(message, percentage)`` — freeform; for indeterminate progress or custom logic.
+    """
+
+    def __init__(
+        self,
+        sender: ProgressSender,
+        title: str,
+        *,
+        total: int | None = None,
+        cancellable: bool = False,
+    ) -> None:
+        self._sender = sender
+        self._title = title
+        self._total = total
+        self._cancellable = cancellable
+        self._completed = 0
+
+    async def __aenter__(self) -> ProgressContext:
+        percentage = 0 if self._total is not None else None
+        await self._sender.begin(
+            self._title,
+            percentage=percentage,
+            cancellable=self._cancellable,
+            total=self._total,
+        )
+        return self
+
+    async def __aexit__(self, *exc) -> bool:
+        await self._sender.end()
+        return False
+
+    async def advance(self, steps: int = 1, message: str | None = None) -> None:
+        """Step-based progress. Auto-calculates percentage from total."""
+        self._completed += steps
+        percentage = None
+        if self._total is not None:
+            percentage = min(int(self._completed / self._total * 100), 100)
+        await self._sender.report(message=message, percentage=percentage)
+
+    async def report(self, message: str | None = None, percentage: int | None = None) -> None:
+        """Freeform progress. Caller controls the percentage directly."""
+        await self._sender.report(message=message, percentage=percentage)
+
+
 class RunActionContext(typing.Generic[RunPayloadType]):
     # data object to save data between action steps(only during one run, after run data
     # is removed). Keep it simple, without business logic, just data storage, but you
@@ -116,13 +211,27 @@ def __init__(
         meta: RunActionMeta,
         info_provider: RunContextInfoProvider,
         partial_result_sender: PartialResultSender = _NOOP_SENDER,
+        progress_sender: ProgressSender = _NOOP_PROGRESS_SENDER,
     ) -> None:
         self.run_id = run_id
         self.initial_payload = initial_payload
         self.meta = meta
         self.exit_stack = contextlib.AsyncExitStack()
         self._info_provider = info_provider
         self.partial_result_sender = partial_result_sender
+        self._progress_sender = progress_sender
+
+    def progress(
+        self,
+        title: str,
+        *,
+        total: int | None = None,
+        cancellable: bool = False,
+    ) -> ProgressContext:
+        """Create a progress context manager for reporting progress to the client."""
+        return ProgressContext(
+            self._progress_sender, title, total=total, cancellable=cancellable
+        )
 
     @property
     def current_result(self) -> RunActionResult | None:
@@ -165,13 +274,15 @@ def __init__(
         meta: RunActionMeta,
         info_provider: RunContextInfoProvider,
         partial_result_sender: PartialResultSender = _NOOP_SENDER,
+        progress_sender: ProgressSender = _NOOP_PROGRESS_SENDER,
     ) -> None:
         super().__init__(
             run_id=run_id,
             initial_payload=initial_payload,
             meta=meta,
             info_provider=info_provider,
             partial_result_sender=partial_result_sender,
+            progress_sender=progress_sender,
         )
         self.partial_result_scheduler = partialresultscheduler.PartialResultScheduler()
 

finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py

@@ -66,6 +66,60 @@ def set_partial_result_sender(send_func: typing.Callable) -> None:
     )
 
 
+progress_sender_func: typing.Callable | None = None
+
+
+def set_progress_sender(send_func: typing.Callable) -> None:
+    global progress_sender_func
+    progress_sender_func = send_func
+
+
+class _ERProgressSender:
+    """Concrete ProgressSender that sends notifications via the ER LSP server."""
+
+    def __init__(
+        self,
+        token: int | str,
+        send_func: typing.Callable[[int | str, dict], None],
+    ) -> None:
+        self._token = token
+        self._send_func = send_func
+
+    async def begin(
+        self,
+        title: str,
+        message: str | None = None,
+        percentage: int | None = None,
+        cancellable: bool = False,
+        total: int | None = None,
+    ) -> None:
+        self._send_func(self._token, {
+            "type": "begin",
+            "title": title,
+            "message": message,
+            "percentage": percentage,
+            "cancellable": cancellable,
+            "total": total,
+        })
+
+    async def report(
+        self,
+        message: str | None = None,
+        percentage: int | None = None,
+    ) -> None:
+        self._send_func(self._token, {
+            "type": "report",
+            "message": message,
+            "percentage": percentage,
+        })
+
+    async def end(self, message: str | None = None) -> None:
+        self._send_func(self._token, {
+            "type": "end",
+            "message": message,
+        })
+
+
 class AsyncPlaceholderContext:
     async def __aenter__(self):
         return self
@@ -78,6 +132,7 @@ async def run_action(
     payload: code_action.RunActionPayload | None,
     meta: code_action.RunActionMeta,
     partial_result_token: int | str | None = None,
+    progress_token: int | str | None = None,
     run_id: int | None = None,
     partial_result_queue: asyncio.Queue | None = None,
 ) -> code_action.RunActionResult | None:
@@ -132,6 +187,15 @@ async def run_action(
         )
     else:
         tracking_sender = None
+
+    if progress_token is not None and progress_sender_func is not None:
+        er_progress_sender: code_action.ProgressSender = _ERProgressSender(
+            token=progress_token,
+            send_func=progress_sender_func,
+        )
+    else:
+        er_progress_sender = code_action._NOOP_PROGRESS_SENDER
+
     if action_exec_info.run_context_type is not None:
         constructor_args = await resolve_func_args_with_di(
             action_exec_info.run_context_type.__init__,
@@ -141,6 +205,7 @@ async def run_action(
                 "meta": lambda _: meta,
                 "info_provider": lambda _: run_context_info,
                 "partial_result_sender": lambda _: tracking_sender or code_action._NOOP_SENDER,
+                "progress_sender": lambda _: er_progress_sender,
             },
             params_to_ignore=["self"],
         )
@@ -414,6 +479,7 @@ async def run_action_raw(
         payload=payload,
         meta=options.meta,
         partial_result_token=options.partial_result_token,
+        progress_token=options.progress_token,
         run_id=run_id,
     )
 

finecode_extension_runner/src/finecode_extension_runner/lsp_server.py

@@ -172,6 +172,13 @@ async def lsp_connection(
             )
             logger.debug("Main loop finished")
             self.shutdown()
+            # Close the writer so the transport is removed from the server's
+            # active-client set (_clients). Without this, eof_received() returns
+            # True (half-close) and the transport lingers, causing wait_closed()
+            # inside serve_forever() to block indefinitely — the ghost-process
+            # scenario when the IDE closes without a clean LSP shutdown.
+            writer.close()
+            self._server.close()
 
         async def tcp_server(h: str, p: int):
             self._server = await asyncio.start_server(lsp_connection, h, p)
@@ -212,6 +219,13 @@ async def lsp_connection(
             )
             logger.debug("Main loop finished")
             self.shutdown()
+            # Close the writer so the transport is removed from the server's
+            # active-client set (_clients). Without this, eof_received() returns
+            # True (half-close) and the transport lingers, causing wait_closed()
+            # inside serve_forever() to block indefinitely — the ghost-process
+            # scenario when the IDE closes without a clean LSP shutdown/exit.
+            writer.close()
+            self._server.close()
 
         self._server = await asyncio.start_server(lsp_connection, host, port)
 
@@ -221,6 +235,8 @@ async def lsp_connection(
         try:
             async with self._server:
                 await self._server.serve_forever()
+        except asyncio.CancelledError:
+            logger.debug("TCP server closed after client disconnect")
         finally:
             await self._finecode_exit_stack.aclose()
 
@@ -297,6 +313,9 @@ def create_lsp_server() -> lsp_server.LanguageServer:
     register_get_payload_schemas_cmd = server.command("actions/getPayloadSchemas")
     register_get_payload_schemas_cmd(get_payload_schemas_cmd)
 
+    register_get_runner_info_cmd = server.command("finecodeRunner/getInfo")
+    register_get_runner_info_cmd(get_runner_info)
+
     def on_process_exit():
         logger.info("Exit extension runner")
         services.shutdown_all_action_handlers()
@@ -315,6 +334,15 @@ def send_partial_result(
         server.progress(types.ProgressParams(token=token, value=partial_result_json))
 
     run_action_service.set_partial_result_sender(send_partial_result)
+
+    def send_progress(token: int | str, value_dict: dict) -> None:
+        value_json = json.dumps(value_dict)
+        logger.trace(
+            f"send_progress: token={token}, type={value_dict.get('type')}, preview={value_json[:200]}"
+        )
+        server.progress(types.ProgressParams(token=token, value=value_json))
+
+    run_action_service.set_progress_sender(send_progress)
 
     return server
 
@@ -580,3 +608,9 @@ async def merge_results_cmd(ls: lsp_server.LanguageServer, action_name: str, res
     except Exception as exception:
         logger.exception(f"Merge results error: {exception}")
         return {"error": str(exception)}
+
+
+async def get_runner_info(ls: lsp_server.LanguageServer):
+    from finecode_extension_runner import global_state
+    log_path = global_state.log_file_path
+    return {"logFilePath": str(log_path) if log_path is not None else None}