Merge pull request #2 from finecode-dev/feature/cli

CLI for running actions

Author: Aksem

README.md

@@ -43,6 +43,31 @@ presets = [
 
 1.5 For integration with VSCode, install [FineCode extension](https://github.com/finecode-dev/finecode-vscode)
 
+## CLI
+
+In virtualenv of your project you can use the following command:
+
+`python -m finecode run [run_options] <list_of_actions> [actions_payload]`
+
+Available run options:
+
+- `--workdir="<path>"` ... use provided directory as work directory
+- `--project="<name>"` ... run actions only in this project. Multiple projects can be selected by providing multiple `--project="<name>"` options
+- `--concurrently` ... run actions concurrently. Single projects are always handled concurrently, this option determines whether actions inside of single project are run concurrently or not
+- `--trace` ... activate trace(more detailed) logging
+
+If no projects are provided via options, FineCode will interpret working directory as workspace root, find all projects in it and run provided actions in all projects, in which they exist.
+
+If projects are provided, actions are expected to exist in all of them.
+
+Actions payload: if actions require payload or you want to run them with payload other than configured, you can provide it after names of actions.
+
+Examples:
+
+- `python -m finecode run --concurrently lint check_formatting` ... run `lint` and `check_formatting` actions concurrently in all projects in the workspace, root of which is in current working directory
+- `python -m finecode --workdir="./finecode_extension_api" run lint check_formatting` ... run `lint` and `check_formatting` sequentially in `finecode_extension_api` directory (project is there)
+- `python -m finecode --project="fine_python_mypy" --project="fine_python_ruff" run lint` ... run `lint` action in projects `fine_python_mypy` and `fine_python_ruff`. They should be discoverable from the working directory.
+
 ## Extensions from FineCode authors
 
 ### Presets
@@ -66,3 +91,20 @@ presets = [
 IDE
 
 TODO: list all from LSP
+
+## Workspace with multiple subprojects
+
+### Reusing config
+
+To reuse configuration in multiple subprojects, put it in a separate package in your workspace and add it as dev dependency in all subprojects in which you want to use it.
+
+Design decision: there are multiple ways to achieve the same result:
+
+- separate package
+  - configuration of subprojects doesn't depend on file structure of the workspace. Subproject can be moved in another place or even outside of workspace and this will not affect its configuration, only if path to package with common configuration was file path, it should be changed.
+  - fully transparent: the full configuration is known in a subproject without searching workspace root and analyzing the workspace
+- hierarchical configuration
+  - makes subprojects more dependent on workspace, in case of moving subproject, additional actions with configurations are needed to keep it the same
+- letting to define reusable part on workspace level and provide it automatically to all subprojects
+  - not transparent, part of configuration is implicit
+  - FineCode needs to check whether it was started in workspace or in subproject, go deeper in file tree and find workspace root to resolve all configurations

finecode/__main__.py

@@ -0,0 +1,4 @@
+from finecode.workspace_manager import cli as wm_cli
+
+if __name__ == "__main__":
+    wm_cli.cli()

finecode/extension_runner/bootstrap.py

@@ -31,7 +31,7 @@
     icache,
     icommandrunner,
     ifilemanager,
-    ilogger
+    ilogger,
 )
 
 container: dict[str, Any] = {}

finecode/extension_runner/cli.py

@@ -4,8 +4,8 @@
 import click
 from loguru import logger
 
-from finecode.extension_runner import global_state
 import finecode.extension_runner.start as runner_start
+from finecode.extension_runner import global_state
 
 
 @click.command()

finecode/extension_runner/impls/process_executor.py

@@ -4,8 +4,8 @@
 import contextlib
 import functools
 import multiprocessing as mp
-import typing
 import sys
+import typing
 
 from loguru import logger
 
@@ -37,7 +37,7 @@ async def submit[T, **P](
             raise Exception("Process Executor is not activated")
 
         if self._py_process_executor is None:
-            if sys.version_info < (3, 14, 0) and sys.platform == 'linux':
+            if sys.version_info < (3, 14, 0) and sys.platform == "linux":
                 # forkserver is default on linux in Python 3.14+, use the same also
                 # with older versions
                 mp_context = mp.get_context("forkserver")

finecode/extension_runner/lsp_server.py

@@ -194,7 +194,11 @@ async def run_action(ls: lsp_server.LanguageServer, params):
     # dict key can be path, but pygls fails to handle slashes in dict keys, use strings
     # representation of result instead until the problem is properly solved
     result_str = json.dumps(response.to_dict()["result"])
-    return {"result": result_str}
+    return {
+        "result": result_str,
+        "format": response.format,
+        "return_code": response.return_code,
+    }
 
 
 async def reload_action(ls: lsp_server.LanguageServer, params):

finecode/extension_runner/schemas.py

@@ -1,6 +1,6 @@
 from dataclasses import asdict, dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 
 @dataclass
@@ -44,9 +44,12 @@ class RunActionRequest(BaseSchema):
 @dataclass
 class RunActionOptions(BaseSchema):
     partial_result_token: int | str | None = None
+    result_format: Literal["json"] | Literal["string"] = "json"
 
 
 @dataclass
 class RunActionResponse(BaseSchema):
+    return_code: int
     # result can be empty(=None) e.g. if it was sent as a list of partial results
     result: dict[str, Any] | None
+    format: Literal["json"] | Literal["string"] | Literal["styled_text_json"] = "json"

finecode/extension_runner/services.py

@@ -16,7 +16,7 @@
     partial_result_sender as partial_result_sender_module,
 )
 from finecode.extension_runner import project_dirs, run_utils, schemas
-from finecode_extension_api import code_action
+from finecode_extension_api import code_action, textstyler
 
 
 class ActionFailedException(Exception): ...
@@ -169,7 +169,7 @@ async def run_subresult_coros_concurrently(
     partial_result_token: int | str,
     partial_result_sender: partial_result_sender_module.PartialResultSender,
     action_name: str,
-    run_id: int
+    run_id: int,
 ) -> code_action.RunActionResult | None:
     coros_tasks: list[asyncio.Task] = []
     try:
@@ -178,10 +178,12 @@ async def run_subresult_coros_concurrently(
                 coro_task = tg.create_task(coro)
                 coros_tasks.append(coro_task)
     except ExceptionGroup as eg:
-        logger.error(f'R{run_id} | {eg}')
+        logger.error(f"R{run_id} | {eg}")
         for exc in eg.exceptions:
             logger.exception(exc)
-        raise ActionFailedException(f"Concurrent running action handlers of '{action_name}' failed(Run {run_id}). See logs for more details")
+        raise ActionFailedException(
+            f"Concurrent running action handlers of '{action_name}' failed(Run {run_id}). See logs for more details"
+        )
 
     action_subresult: code_action.RunActionResult | None = None
     for coro_task in coros_tasks:
@@ -207,15 +209,17 @@ async def run_subresult_coros_sequentially(
     partial_result_token: int | str,
     partial_result_sender: partial_result_sender_module.PartialResultSender,
     action_name: str,
-    run_id: int
+    run_id: int,
 ) -> code_action.RunActionResult | None:
     action_subresult: code_action.RunActionResult | None = None
     for coro in coros:
         try:
             coro_result = await coro
         except Exception as e:
             logger.exception(e)
-            raise ActionFailedException(f"Running action handlers of '{action_name}' failed(Run {run_id}): {e}")
+            raise ActionFailedException(
+                f"Running action handlers of '{action_name}' failed(Run {run_id}): {e}"
+            )
 
         if coro_result is not None:
             if action_subresult is None:
@@ -245,7 +249,9 @@ async def run_action(
     # TODO: check whether config is set: this will be solved by passing initial
     # configuration as payload of initialize
     if global_state.runner_context is None:
-        raise ActionFailedException(f"Run of action failed because extension runner is not initialized yet")
+        raise ActionFailedException(
+            "Run of action failed because extension runner is not initialized yet"
+        )
 
     start_time = time.time_ns()
     project_def = global_state.runner_context.project
@@ -254,7 +260,9 @@ async def run_action(
         action = project_def.actions[request.action_name]
     except KeyError:
         logger.error(f"R{run_id} | Action {request.action_name} not found")
-        raise ActionFailedException(f"R{run_id} | Action {request.action_name} not found")
+        raise ActionFailedException(
+            f"R{run_id} | Action {request.action_name} not found"
+        )
 
     # design decisions:
     # - keep payload unchanged between all subaction runs.
@@ -341,20 +349,18 @@ async def run_action(
             try:
                 async with asyncio.TaskGroup() as tg:
                     for part in parts:
-                        part_coros = run_context.partial_result_scheduler.coroutines_by_key[
-                            part
-                        ]
-                        del run_context.partial_result_scheduler.coroutines_by_key[
-                            part
-                        ]
+                        part_coros = (
+                            run_context.partial_result_scheduler.coroutines_by_key[part]
+                        )
+                        del run_context.partial_result_scheduler.coroutines_by_key[part]
                         if execute_handlers_concurrently:
                             coro = run_subresult_coros_concurrently(
                                 part_coros,
                                 send_partial_results,
                                 partial_result_token,
                                 partial_result_sender,
                                 action.name,
-                                run_id
+                                run_id,
                             )
                         else:
                             coro = run_subresult_coros_sequentially(
@@ -363,15 +369,18 @@ async def run_action(
                                 partial_result_token,
                                 partial_result_sender,
                                 action.name,
-                                run_id
+                                run_id,
                             )
                         subresult_task = tg.create_task(coro)
                         subresults_tasks.append(subresult_task)
             except ExceptionGroup as eg:
                 logger.error(eg)
                 for exc in eg.exceptions:
                     logger.exception(exc)
-                raise ActionFailedException(f"Running action handlers of '{action.name}' failed(Run {run_id}). See ER logs for more details")
+                raise ActionFailedException(
+                    f"Running action handlers of '{action.name}' failed(Run {run_id})."
+                    " See ER logs for more details"
+                )
 
             if send_partial_results:
                 # all subresults are ready
@@ -408,7 +417,10 @@ async def run_action(
                     logger.error(eg)
                     for exc in eg.exceptions:
                         logger.exception(exc)
-                    raise ActionFailedException(f"Running action handlers of '{action.name}' failed(Run {run_id}). See ER logs for more details")
+                    raise ActionFailedException(
+                        f"Running action handlers of '{action.name}' failed"
+                        f"(Run {run_id}). See ER logs for more details"
+                    )
 
                 for handler_task in handlers_tasks:
                     coro_result = handler_task.result()
@@ -435,9 +447,26 @@ async def run_action(
                         else:
                             action_result.update(handler_result)
 
-    result_dict = None
+    serialized_result: dict[str, Any] | str | None = None
+    result_format = "string"
+    run_return_code = code_action.RunReturnCode.SUCCESS
     if isinstance(action_result, code_action.RunActionResult):
-        result_dict = action_result.model_dump(mode="json")
+        run_return_code = action_result.return_code
+        if options.result_format == "json":
+            serialized_result = action_result.model_dump(mode="json")
+            result_format = "json"
+        elif options.result_format == "string":
+            result_text = action_result.to_text()
+            if isinstance(result_text, textstyler.StyledText):
+                serialized_result = result_text.to_json()
+                result_format = "styled_text_json"
+            else:
+                serialized_result = result_text
+                result_format = "string"
+        else:
+            raise ActionFailedException(
+                f"Unsupported result format: {options.result_format}"
+            )
     elif action_result is not None:
         logger.error(
             f"R{run_id} | Unexpected result type: {type(action_result).__name__}"
@@ -451,7 +480,11 @@ async def run_action(
     logger.trace(
         f"R{run_id} | Run action end '{request.action_name}', duration: {duration}ms"
     )
-    return schemas.RunActionResponse(result=result_dict)
+    return schemas.RunActionResponse(
+        result=serialized_result,
+        format=result_format,
+        return_code=run_return_code.value,
+    )
 
 
 async def execute_action_handler(
@@ -570,7 +603,9 @@ def get_run_context(param_type):
             execution_result = call_result
     except Exception as e:
         logger.exception(e)
-        raise ActionFailedException(f"Running action handler '{handler.name}' failed(Run {run_id}): {e}")
+        raise ActionFailedException(
+            f"Running action handler '{handler.name}' failed(Run {run_id}): {e}"
+        )
 
     end_time = time.time_ns()
     duration = (end_time - start_time) / 1_000_000

finecode/pygls_server_utils.py

@@ -82,10 +82,7 @@ def deserialize_pygls_object(pygls_object) -> dict[str, Any] | list[Any]:
         deserialized = []
         for index in range(len(pygls_object)):
             item = getattr(pygls_object, f"_{index}")
-            if (
-                hasattr(item, "__module__")
-                and item.__module__ == "pygls.protocol"
-            ):
+            if hasattr(item, "__module__") and item.__module__ == "pygls.protocol":
                 deserialized_value = deserialize_pygls_object(item)
             else:
                 deserialized_value = item