update

Author: observerw

python/docs/locate_design.md

@@ -6,7 +6,7 @@
 import asyncer
 from attrs import define
 from lsap_schema.definition import DefinitionRequest, DefinitionResponse
-from lsap_schema.types import SymbolInfo
+from lsap_schema.types import SymbolCodeInfo
 from lsp_client.capability.request import (
     WithRequestDeclaration,
     WithRequestDefinition,
@@ -73,18 +73,16 @@ async def __call__(self, req: DefinitionRequest) -> DefinitionResponse | None:
         infos = []
         async with asyncer.create_task_group() as tg:
 
-            async def resolve_item(loc: Location) -> SymbolInfo | None:
+            async def resolve_item(loc: Location) -> SymbolCodeInfo | None:
                 target_file_path = self.client.from_uri(loc.uri)
                 if symbol_info := await self.symbol.resolve(
                     target_file_path,
                     loc.range.start,
-                    include_hover=req.include_hover,
-                    include_code=req.include_code,
                 ):
                     return symbol_info
 
             infos = [tg.soonify(resolve_item)(loc) for loc in locations]
-        items: list[SymbolInfo] = [
+        items: list[SymbolCodeInfo] = [
             value for info in infos if (value := info.value) is not None
         ]
 

python/src/lsap/definition.py

@@ -1,5 +1,5 @@
 from functools import cached_property
-from typing import Protocol, cast, override, runtime_checkable
+from typing import Protocol, override, runtime_checkable
 
 from attrs import Factory, define
 from lsap_schema.draft.completion import (
@@ -57,7 +57,14 @@ async def fetcher() -> list[CompletionItem] | None:
             for lsp_item in lsp_items:
                 kind = "Unknown"
                 if lsp_item.kind is not None:
-                    kind = cast(CompletionItemKind, lsp_item.kind).name
+                    if isinstance(lsp_item.kind, CompletionItemKind):
+                        kind = lsp_item.kind.name
+                    else:
+                        # Handle case where it might be a raw integer
+                        try:
+                            kind = CompletionItemKind(lsp_item.kind).name
+                        except ValueError:
+                            kind = str(lsp_item.kind)
 
                 documentation = None
                 if lsp_item.documentation:

python/src/lsap/draft/completion.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Literal, Protocol, override, runtime_checkable
+
+from attrs import Factory, define
+from lsap_schema.draft.diagnostics import (
+    Diagnostic,
+    FileDiagnosticsRequest,
+    FileDiagnosticsResponse,
+)
+from lsap_schema.types import Position, Range
+from lsp_client.capability.request import WithDocumentDiagnostic
+from lsp_client.protocol import CapabilityClientProtocol
+from lsprotocol.types import DiagnosticSeverity
+
+from lsap.abc import Capability
+from lsap.utils.cache import PaginationCache
+from lsap.utils.pagination import paginate
+
+
+@runtime_checkable
+class DiagnosticsClient(WithDocumentDiagnostic, CapabilityClientProtocol, Protocol): ...
+
+
+@define
+class FileDiagnosticsCapability(
+    Capability[DiagnosticsClient, FileDiagnosticsRequest, FileDiagnosticsResponse]
+):
+    _cache: PaginationCache[Diagnostic] = Factory(PaginationCache)
+
+    @override
+    async def __call__(
+        self, req: FileDiagnosticsRequest
+    ) -> FileDiagnosticsResponse | None:
+        async def fetcher() -> list[Diagnostic] | None:
+            lsp_diagnostics = await self.client.request_diagnostics(req.file_path)
+            if lsp_diagnostics is None:
+                return None
+
+            severity_map: dict[
+                DiagnosticSeverity, Literal["Error", "Warning", "Information", "Hint"]
+            ] = {
+                DiagnosticSeverity.Error: "Error",
+                DiagnosticSeverity.Warning: "Warning",
+                DiagnosticSeverity.Information: "Information",
+                DiagnosticSeverity.Hint: "Hint",
+            }
+
+            items = []
+            for d in lsp_diagnostics:
+                severity: Literal["Error", "Warning", "Information", "Hint"] = (
+                    "Information"
+                )
+                if d.severity is not None:
+                    try:
+                        severity = severity_map[DiagnosticSeverity(d.severity)]
+                    except (KeyError, ValueError):
+                        pass
+
+                items.append(
+                    Diagnostic(
+                        range=Range(
+                            start=Position.from_lsp(d.range.start),
+                            end=Position.from_lsp(d.range.end),
+                        ),
+                        severity=severity,
+                        message=d.message,
+                        source=d.source,
+                        code=d.code,
+                    )
+                )
+
+            # Filter by min_severity
+            severity_order = ["Hint", "Information", "Warning", "Error"]
+            min_idx = severity_order.index(req.min_severity)
+            items = [i for i in items if severity_order.index(i.severity) >= min_idx]
+
+            return items
+
+        result = await paginate(req, self._cache, fetcher)
+        if result is None:
+            return None
+
+        return FileDiagnosticsResponse(
+            file_path=req.file_path,
+            diagnostics=result.items,
+            start_index=req.start_index,
+            max_items=req.max_items,
+            total=result.total,
+            has_more=result.has_more,
+            pagination_id=result.pagination_id,
+        )

python/src/lsap/draft/diagnostics.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import Protocol, override, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 from attrs import define
 from lsap_schema.hover import HoverRequest, HoverResponse
@@ -26,7 +26,6 @@ class HoverCapability(Capability[HoverClient, HoverRequest, HoverResponse]):
     def locate(self) -> LocateCapability:
         return LocateCapability(self.client)
 
-    @override
     async def __call__(self, req: HoverRequest) -> HoverResponse | None:
         if not (loc_resp := await self.locate(req)):
             return None
@@ -37,16 +36,4 @@ async def __call__(self, req: HoverRequest) -> HoverResponse | None:
         if hover is None:
             return None
 
-        contents = ""
-        if isinstance(hover.value, str):
-            contents = hover.contents
-        elif isinstance(hover.contents, list):
-            contents = "\n".join(
-                c if isinstance(c, str) else c.value for c in hover.contents
-            )
-        else:
-            contents = hover.contents.value
-
-        return HoverResponse(
-            contents=contents,
-        )
+        return HoverResponse(content=hover.value)

python/src/lsap/hover.py

@@ -4,7 +4,7 @@
 import asyncer
 from attrs import Factory, define
 from lsap_schema.reference import ReferenceItem, ReferenceRequest, ReferenceResponse
-from lsap_schema.types import SymbolInfo, SymbolKind
+from lsap_schema.types import Position, Range, SymbolDetailInfo, SymbolKind
 from lsp_client.capability.request import (
     WithRequestDocumentSymbol,
     WithRequestHover,
@@ -116,19 +116,26 @@ async def _process_reference(
         if not (snippet := reader.read(context_range)):
             return
 
-        symbol: SymbolInfo | None = None
+        symbol: SymbolDetailInfo | None = None
         if symbols := await self.client.request_document_symbol_list(file_path):
             if match := symbol_at(symbols, range_.start):
                 path, sym = match
                 kind = SymbolKind.from_lsp(sym.kind)
 
-                symbol = SymbolInfo(
+                symbol = SymbolDetailInfo(
                     file_path=file_path,
                     name=sym.name,
                     path=path,
                     kind=kind,
-                    detail=sym.detail,
+                    detail=sym.detail or "",
+                    hover="",
+                    range=Range(
+                        start=Position.from_lsp(sym.range.start),
+                        end=Position.from_lsp(sym.range.end),
+                    ),
                 )
+                if hover := await self.client.request_hover(file_path, range_.start):
+                    symbol.hover = hover.value
 
         items.append(
             ReferenceItem(