update

Author: observerw

src/lsp_cli/__main__.py

@@ -70,6 +70,10 @@ def create_locate(
     find: str | None = None,
     marker: str = "<HERE>",
 ) -> Locate:
+    if line is not None and symbol:
+        console.print("[red]Error:[/red] --line and --symbol are mutually exclusive")
+        raise typer.Exit(1)
+
     scope = None
     if line is not None:
         scope = LineScope(line=line)
@@ -118,9 +122,9 @@ def main(
 @cli_syncify
 async def get_definition(
     file_path: op.FileArg,
-    line: Annotated[int | None, op.LineOpt] = None,
+    line: op.LineOpt = None,
     symbol: op.SymbolPathOpt = None,
-    find: Annotated[str | None, op.FindOpt] = None,
+    find: op.FindOpt = None,
     marker: op.MarkerOpt = "<HERE>",
     mode: Annotated[
         Literal["definition", "declaration", "type_definition"],
@@ -149,13 +153,13 @@ async def get_definition(
 @cli_syncify
 async def get_completion(
     file_path: op.FileArg,
-    line: Annotated[int | None, op.LineOpt] = None,
+    line: op.LineOpt = None,
     symbol: op.SymbolPathOpt = None,
-    find: Annotated[str | None, op.FindOpt] = None,
+    find: op.FindOpt = None,
     marker: op.MarkerOpt = "<HERE>",
-    max_items: Annotated[int | None, op.MaxItemsOpt] = 15,
-    start_index: Annotated[int, op.StartIndexOpt] = 0,
-    pagination_id: Annotated[str | None, op.PaginationIdOpt] = None,
+    max_items: op.MaxItemsOpt = 15,
+    start_index: op.StartIndexOpt = 0,
+    pagination_id: op.PaginationIdOpt = None,
 ):
     locate = create_locate(file_path, line, symbol, find, marker)
 
@@ -180,9 +184,9 @@ async def get_completion(
 @cli_syncify
 async def get_hover(
     file_path: op.FileArg,
-    line: Annotated[int | None, op.LineOpt] = None,
+    line: op.LineOpt = None,
     symbol: op.SymbolPathOpt = None,
-    find: Annotated[str | None, op.FindOpt] = None,
+    find: op.FindOpt = None,
     marker: op.MarkerOpt = "<HERE>",
 ):
     locate = create_locate(file_path, line, symbol, find, marker)
@@ -204,18 +208,25 @@ async def get_hover(
 @cli_syncify
 async def get_reference(
     file_path: op.FileArg,
-    line: op.LineOpt,
+    line: op.LineOpt = None,
     symbol: op.SymbolPathOpt = None,
-    find: Annotated[str | None, op.FindOpt] = None,
+    find: op.FindOpt = None,
     marker: op.MarkerOpt = "<HERE>",
     mode: Annotated[
         Literal["references", "implementations"],
         typer.Option("--mode", "-m", help="Search mode"),
     ] = "references",
-    context_lines: Annotated[int, op.ContextLinesOpt] = 2,
-    max_items: Annotated[int | None, op.MaxItemsOpt] = None,
-    start_index: Annotated[int, op.StartIndexOpt] = 0,
-    pagination_id: Annotated[str | None, op.PaginationIdOpt] = None,
+    context_lines: Annotated[
+        int,
+        typer.Option(
+            "--context-lines",
+            "-C",
+            help="Lines of context around match",
+        ),
+    ] = 2,
+    max_items: op.MaxItemsOpt = None,
+    start_index: op.StartIndexOpt = 0,
+    pagination_id: op.PaginationIdOpt = None,
 ):
     locate = create_locate(file_path, line, symbol, find, marker)
 
@@ -260,9 +271,9 @@ async def get_outline(file_path: op.FileArg):
 @cli_syncify
 async def get_symbol(
     file_path: op.FileArg,
-    line: Annotated[int | None, op.LineOpt] = None,
+    line: op.LineOpt = None,
     symbol: op.SymbolPathOpt = None,
-    find: Annotated[str | None, op.FindOpt] = None,
+    find: op.FindOpt = None,
     marker: op.MarkerOpt = "<HERE>",
 ):
     locate = create_locate(file_path, line, symbol, find, marker)
@@ -287,9 +298,9 @@ async def get_symbol(
 async def search_workspace_symbol(
     query: Annotated[str, typer.Argument(help="Symbol name to search")],
     path: op.FileArg,
-    max_items: Annotated[int | None, op.MaxItemsOpt] = None,
-    start_index: Annotated[int, op.StartIndexOpt] = 0,
-    pagination_id: Annotated[str | None, op.PaginationIdOpt] = None,
+    max_items: op.MaxItemsOpt = None,
+    start_index: op.StartIndexOpt = 0,
+    pagination_id: op.PaginationIdOpt = None,
 ):
     async with init_client(path) as client:
         if not isinstance(client, WorkspaceSymbolClient):

src/lsp_cli/manager/client.py

@@ -104,18 +104,28 @@ def get_client_id(target: TargetClient) -> str:
 @define
 class ManagedClient:
     target: TargetClient
-    _server: uvicorn.Server | None = field(init=False, default=None)
-    _timeout_scope: anyio.CancelScope | None = field(init=False, default=None)
-    _server_scope: anyio.CancelScope | None = field(init=False, default=None)
+    _server: uvicorn.Server = field(init=False)
+    _timeout_scope: anyio.CancelScope = field(init=False)
+    _server_scope: anyio.CancelScope = field(init=False)
 
     _deadline: float = Factory(lambda: anyio.current_time() + settings.idle_timeout)
     _should_exit: bool = False
 
-    _log_handler_id: int | None = field(init=False, default=None)
-
     @cached_property
     def logger(self) -> loguru.Logger:
-        return logger.bind(client_id=self.id)
+        logger.bind(client_id=self.id)
+
+        client_log_dir = LOG_DIR / "clients"
+        client_log_dir.mkdir(parents=True, exist_ok=True)
+        logger.add(
+            client_log_dir / f"{self.id}.log",
+            rotation="10 MB",
+            retention="1 day",
+            level="DEBUG",
+            filter=lambda record: record["extra"].get("client_id") == self.id,
+        )
+
+        return logger
 
     @property
     def id(self) -> str:
@@ -136,33 +146,19 @@ def info(self) -> ManagedClientInfo:
     def stop(self) -> None:
         self.logger.info("Stopping managed client {}", self.id)
         self._should_exit = True
-        if self._server:
-            self._server.should_exit = True
-        if self._server_scope:
-            self._server_scope.cancel()
-        if self._timeout_scope:
-            self._timeout_scope.cancel()
+        self._server.should_exit = True
+        self._server_scope.cancel()
+        self._timeout_scope.cancel()
 
     async def run(self) -> None:
-        client_log_dir = LOG_DIR / "clients"
-        client_log_dir.mkdir(parents=True, exist_ok=True)
-        self._log_handler_id = logger.add(
-            client_log_dir / f"{self.id}.log",
-            rotation="10 MB",
-            retention="1 day",
-            level="DEBUG",
-            filter=lambda record: record["extra"].get("client_id") == self.id,
-        )
-
         self.logger.info(
             "Starting managed client {} for project {} at {}",
             self.id,
             self.target.project_path,
             self.uds_path,
         )
         async with AsyncExitStack() as stack:
-            if self._log_handler_id is not None:
-                stack.callback(lambda: logger.remove(self._log_handler_id))
+            stack.callback(lambda: logger.remove(self._log_handler_id))
 
             uds_path = anyio.Path(self.uds_path)
             await uds_path.unlink(missing_ok=True)
@@ -228,11 +224,8 @@ async def handle_package(
             self._server = uvicorn.Server(config)
 
             def cleanup_server():
-                self._server = None
-                if self._timeout_scope:
-                    self._timeout_scope.cancel()
-                if self._server_scope:
-                    self._server_scope.cancel()
+                self._timeout_scope.cancel()
+                self._server_scope.cancel()
 
             stack.callback(cleanup_server)
 
@@ -244,12 +237,11 @@ def cleanup_server():
 
     def _reset_timeout(self) -> None:
         self._deadline = anyio.current_time() + settings.idle_timeout
-        if self._timeout_scope:
-            self._timeout_scope.cancel()
+        self._timeout_scope.cancel()
 
     async def _timeout_loop(self) -> None:
         while not self._should_exit:
-            if self._server and self._server.should_exit:
+            if self._server.should_exit:
                 break
             remaining = self._deadline - anyio.current_time()
             if remaining <= 0:
@@ -258,7 +250,5 @@ async def _timeout_loop(self) -> None:
                 self._timeout_scope = scope
                 await anyio.sleep(remaining)
 
-        if self._server:
-            self._server.should_exit = True
-        if self._server_scope:
-            self._server_scope.cancel()
+        self._server.should_exit = True
+        self._server_scope.cancel()

src/lsp_cli/options.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Annotated, Literal
+from typing import Annotated
 
 import typer
 
@@ -16,6 +16,7 @@
         "--line",
         "-l",
         help="Line number (1-indexed)",
+        rich_help_panel="Scope",
     ),
 ]
 
@@ -25,15 +26,16 @@
         "--find",
         "-f",
         help="Text snippet to find",
+        rich_help_panel="Search",
     ),
 ]
 
 MarkerOpt = Annotated[
     str,
     typer.Option(
-        "<HERE>",
         "--marker",
         help="Position marker in find pattern",
+        rich_help_panel="Search",
     ),
 ]
 
@@ -43,109 +45,36 @@
         "--symbol",
         "-s",
         help="Symbol path (multiple for hierarchy)",
-    ),
-]
-
-HoverOpt = Annotated[
-    bool,
-    typer.Option(
-        True,
-        "--hover/--no-hover",
-        help="Include hover information",
-    ),
-]
-
-CodeOpt = Annotated[
-    bool,
-    typer.Option(
-        True,
-        "--code/--no-code",
-        "-c",
-        help="Include source code",
+        rich_help_panel="Scope",
     ),
 ]
 
 MaxItemsOpt = Annotated[
     int | None,
     typer.Option(
-        None,
         "--max-items",
         "-n",
         help="Max items to return",
+        rich_help_panel="Pagination",
     ),
 ]
 
 StartIndexOpt = Annotated[
     int,
     typer.Option(
-        0,
         "--start-index",
-        "-s",
+        "-i",
         help="Pagination offset",
+        rich_help_panel="Pagination",
     ),
 ]
 
 PaginationIdOpt = Annotated[
     str | None,
     typer.Option(
-        None,
         "--pagination-id",
         "-p",
         help="Pagination token",
-    ),
-]
-
-# New options for alignment with lsap-schema
-
-ContextLinesOpt = Annotated[
-    int,
-    typer.Option(
-        "--context-lines",
-        "-C",
-        help="Lines of context around match",
-    ),
-]
-
-DepthOpt = Annotated[
-    int,
-    typer.Option(
-        "--depth",
-        "-D",
-        help="How many hops to trace in hierarchy",
-    ),
-]
-
-DirectionOpt = Annotated[
-    Literal["incoming", "outgoing", "both"],
-    typer.Option(
-        "--direction",
-        "-d",
-        help="Trace direction for hierarchy",
-    ),
-]
-
-IncludeExternalOpt = Annotated[
-    bool,
-    typer.Option(
-        "--include-external/--no-include-external",
-        help="Include calls to/from external libraries",
-    ),
-]
-
-NewNameOpt = Annotated[
-    str,
-    typer.Option(
-        "--new-name",
-        "-N",
-        help="The new name to apply",
-    ),
-]
-
-MinSeverityOpt = Annotated[
-    Literal["Error", "Warning", "Information", "Hint"],
-    typer.Option(
-        "--min-severity",
-        "-m",
-        help="Minimum severity to include",
+        rich_help_panel="Pagination",
     ),
 ]

tests/test_main_e2e.py

@@ -304,6 +304,14 @@ def test_symbol_e2e(mock_init_client, mock_client):
     assert "my_var" in result.stdout
 
 
+def test_mutual_exclusive_scope():
+    result = runner.invoke(
+        app, ["definition", "test.py", "--line", "5", "--symbol", "MyClass"]
+    )
+    assert result.exit_code != 0
+    assert "mutually exclusive" in result.stdout
+
+
 def test_workspace_symbol_e2e(mock_init_client, mock_client):
     with (
         patch("lsp_cli.__main__.WorkspaceSymbolCapability") as mock_cap_cls,