python-delphi-lsp 3.2.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

delphi_lsp/_version.py

@@ -1 +1 @@
-__version__ = "3.2.2"
+__version__ = "3.3.0"

delphi_lsp/agent_cache.py

@@ -8,6 +8,8 @@ import math
 import os
 import re
 import secrets
+import select
+import signal
 import socket
 import stat
 import subprocess
@@ -20,7 +22,7 @@ from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, fields, is_dataclass, replace
 from functools import lru_cache
 from pathlib import Path
-from types import ModuleType
+from types import FrameType, ModuleType
 
 from watchfiles import watch
 
@@ -50,6 +52,8 @@ _START_LOCK_INCOMPLETE_GRACE_SECONDS = 1.0
 _CACHE_REVISION_CHECK_INTERVAL_SECONDS = 3600.0
 _WATCHER_READY_TIMEOUT_SECONDS = 1.0
 _WATCHER_READY_POLL_MILLISECONDS = 50
+_STOP_TIMEOUT_SECONDS = 15.0
+_STOP_SIGNAL_DELAY_SECONDS = 3.0
 _WATCHED_SUFFIXES = frozenset(
     {".pas", ".pp", ".inc", ".dpr", ".dpk", ".dproj", ".cfg"}
 )
@@ -356,6 +360,51 @@ class CacheClientError(RuntimeError):
         super().__init__(message)
 
 
+class _RequestGuard:
+    def __init__(
+        self,
+        service: _CacheService,
+        connection: socket.socket,
+    ) -> None:
+        self._service = service
+        self._connection = connection
+
+    def check(self) -> None:
+        if self._service.shutdown.is_set():
+            raise CacheClientError(
+                "request_cancelled",
+                "Cache request was cancelled.",
+            )
+        try:
+            readable, _, _ = select.select(
+                (self._connection,),
+                (),
+                (),
+                0,
+            )
+            if readable and not self._connection.recv(1, socket.MSG_PEEK):
+                raise CacheClientError(
+                    "client_disconnected",
+                    "Cache client disconnected.",
+                )
+        except CacheClientError:
+            raise
+        except (OSError, ValueError) as error:
+            raise CacheClientError(
+                "client_disconnected",
+                "Cache client disconnected.",
+            ) from error
+        rss_bytes = current_process_rss_bytes()
+        if (
+            rss_bytes > 0
+            and rss_bytes > self._service.metadata.max_memory_bytes
+        ):
+            raise CacheClientError(
+                "memory_budget_exceeded",
+                "Cache request exceeded the configured RSS memory budget.",
+            )
+
+
 def cache_metadata_path(root: str | Path) -> Path:
     return Path(root).resolve() / ".delphi-lsp" / "agent-cache" / "daemon.json"
 
@@ -752,6 +801,8 @@ class _CacheService:
         self.budget = CacheBudget(metadata.max_memory_bytes)
         self.stats = CacheStats()
         self.lock = threading.Lock()
+        self._request_state_lock = threading.Lock()
+        self._active_requests = 0
         self.started = time.monotonic()
         self.last_activity = self.started
         self.cache_state = "warming"
@@ -836,7 +887,12 @@ class _CacheService:
         )
         self.prewarm_thread.start()
 
-    def request(self, request: dict[str, object]) -> CacheClientResponse:
+    def request(
+        self,
+        request: dict[str, object],
+        *,
+        cancel_check: Callable[[], None] | None = None,
+    ) -> CacheClientResponse:
         action = request.get("action")
         if action == "status":
             warning = "" if request.get("_startup_probe") is True else self._consume_warning()
@@ -863,32 +919,62 @@ class _CacheService:
         self.watcher_ready.wait(timeout=_WATCHER_READY_TIMEOUT_SECONDS)
         if self.watcher_failed.is_set():
             self.context.invalidate_revision_cache()
-        with self.lock:
-            self.last_activity = time.monotonic()
-            before = self.last_revision
-            was_warm = self.context.navigation_cache_is_warm
-            try:
+        with self._request_state_lock:
+            self._active_requests += 1
+        try:
+            with self.lock:
+                self.last_activity = time.monotonic()
+                before = self.last_revision
+                was_warm = self.context.navigation_cache_is_warm
                 try:
-                    response = self.context.handle(request).to_mapping()
-                except AgentProtocolError as error:
-                    raise CacheClientError(error.code, error.message) from None
-                except (OSError, UnicodeError):
-                    raise CacheClientError("source_unavailable", "Source is unavailable.") from None
-                except Exception:
-                    raise CacheClientError("internal_error", "Internal cache error.") from None
-            finally:
-                self._enforce_budget()
-            after = str(response["workspace_revision"])
-            self.last_revision = after
-            self.stats.requests += 1
-            if was_warm:
-                self.stats.warm_hits += 1
-            else:
-                self.stats.rebuilds += 1
-                self.stats.parallel_fallbacks += self.context.parallel_stats.fallbacks
-            if before != after:
-                self.stats.invalidations += 1
-            return CacheClientResponse(response, self._consume_warning())
+                    try:
+                        handled = (
+                            self.context.handle(request)
+                            if cancel_check is None
+                            else self.context.handle(
+                                request,
+                                cancel_check=cancel_check,
+                            )
+                        )
+                        response = handled.to_mapping()
+                    except CacheClientError:
+                        raise
+                    except AgentProtocolError as error:
+                        raise CacheClientError(
+                            error.code,
+                            error.message,
+                        ) from None
+                    except (OSError, UnicodeError):
+                        raise CacheClientError(
+                            "source_unavailable",
+                            "Source is unavailable.",
+                        ) from None
+                    except Exception:
+                        raise CacheClientError(
+                            "internal_error",
+                            "Internal cache error.",
+                        ) from None
+                finally:
+                    self._enforce_budget()
+                after = str(response["workspace_revision"])
+                self.last_revision = after
+                self.stats.requests += 1
+                if was_warm:
+                    self.stats.warm_hits += 1
+                else:
+                    self.stats.rebuilds += 1
+                    self.stats.parallel_fallbacks += (
+                        self.context.parallel_stats.fallbacks
+                    )
+                if before != after:
+                    self.stats.invalidations += 1
+                return CacheClientResponse(
+                    response,
+                    self._consume_warning(),
+                )
+        finally:
+            with self._request_state_lock:
+                self._active_requests -= 1
 
     def _enforce_budget(self) -> None:
         self.last_budget = self.budget.enforce(
@@ -932,6 +1018,8 @@ class _CacheService:
             if context is not None
             else None
         )
+        with self._request_state_lock:
+            busy = self._active_requests > 0
         return {
             "pid": self.metadata.pid, "root": self.metadata.root, "project_file": self.metadata.project_file,
             "version": self.metadata.version, "uptime": now - self.started, "idle_seconds": idle,
@@ -958,6 +1046,7 @@ class _CacheService:
             "workspace_revision": self.last_revision,
             "startup_error": self.startup_error,
             "watcher_active": not self.watcher_failed.is_set(),
+            "busy": busy,
         }
 
 
@@ -1053,7 +1142,15 @@ def _serve_connection(connection: socket.socket, service: _CacheService) -> None
             response: dict[str, object] = {"error": {"code": "authentication_failed", "message": "authentication failed"}}
         else:
             try:
-                result = service.request(request)
+                guard = (
+                    _RequestGuard(service, connection)
+                    if request.get("action") in {"trace", "cpg"}
+                    else None
+                )
+                result = service.request(
+                    request,
+                    cancel_check=guard.check if guard is not None else None,
+                )
                 response = {"payload": result.payload, "warning": result.warning}
             except CacheClientError as error:
                 response = {"error": {"code": error.code, "message": error.message}}
@@ -1105,6 +1202,11 @@ def run_cache_daemon(
         max_disk_cache_bytes,
     )
     watcher: threading.Thread | None = None
+    previous_sigterm: (
+        Callable[[int, FrameType | None], object]
+        | int
+        | None
+    ) = None
     connection_slots = threading.BoundedSemaphore(_CONNECTION_WORKERS)
     connection_pool = ThreadPoolExecutor(
         max_workers=_CONNECTION_WORKERS,
@@ -1112,6 +1214,16 @@ def run_cache_daemon(
     )
     try:
         service = _CacheService(metadata, defer_context=True)
+        if threading.current_thread() is threading.main_thread():
+            previous_sigterm = signal.getsignal(signal.SIGTERM)
+
+            def request_shutdown(
+                _signum: int,
+                _frame: FrameType | None,
+            ) -> None:
+                service.shutdown.set()
+
+            signal.signal(signal.SIGTERM, request_shutdown)
         _write_metadata(metadata)
         watcher = threading.Thread(
             target=_watch_workspace,
@@ -1150,6 +1262,8 @@ def run_cache_daemon(
         _remove_metadata_if_owned(metadata)
         if watcher is not None:
             watcher.join(timeout=2.0)
+        if previous_sigterm is not None:
+            signal.signal(signal.SIGTERM, previous_sigterm)
 
 
 def _start_cache_unlocked(
@@ -1339,15 +1453,28 @@ def stop_cache(root: str | Path) -> None:
         _client_exchange(metadata, {"action": "stop"})
     except CacheClientError:
         pass
-    deadline = time.monotonic() + 3
+    started = time.monotonic()
+    deadline = started + _STOP_TIMEOUT_SECONDS
+    signal_sent = False
     stopped = False
-    while time.monotonic() < deadline:
+    while True:
+        now = time.monotonic()
+        if now >= deadline:
+            break
         if _reap_child_if_exited(metadata.pid):
             stopped = True
             break
         if not _pid_alive(metadata.pid):
             stopped = True
             break
+        if (
+            not signal_sent
+            and os.name != "nt"
+            and now - started >= _STOP_SIGNAL_DELAY_SECONDS
+        ):
+            with contextlib.suppress(OSError):
+                os.kill(metadata.pid, signal.SIGTERM)
+            signal_sent = True
         time.sleep(0.05)
     if not stopped and _pid_alive(metadata.pid):
         raise CacheClientError("stop_failed", "Cache daemon did not stop.")

delphi_lsp/agent_cli.py

@@ -25,7 +25,13 @@ from .agent_cache import (
     watch_workspace_changes,
 )
 from .agent_context import AgentContext
-from .agent_layers import build_codebase_index, layer_payload, render_layer
+from .agent_layers import (
+    build_codebase_index,
+    build_references_payload,
+    layer_payload,
+    render_layer,
+    render_payload,
+)
 from .agent_protocol import (
     SCHEMA_VERSION,
     SUPPORTED_ACTIONS,
@@ -317,6 +323,17 @@ def _discard_broken_stdout() -> None:
 def _view(args: argparse.Namespace) -> None:
     args.root = _workspace_root(args.root)
     args.project_file = _project_file(args.root, args.project_file)
+    if args.layer == "references":
+        payload = build_references_payload(
+            args.root,
+            query=args.query,
+            project_file=args.project_file,
+            workers=args.workers,
+        )
+        sys.stdout.write(
+            render_payload(payload, output_format=args.format)
+        )
+        return
     index = build_codebase_index(
         args.root,
         project_file=args.project_file,

delphi_lsp/agent_context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import gc
 import hashlib
 import json
 import sys
@@ -7,7 +8,7 @@ import time
 import unicodedata
 from bisect import bisect_left, bisect_right
 from collections import OrderedDict
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, replace
 from heapq import heappop, heappush
 from pathlib import Path, PureWindowsPath
@@ -704,6 +705,26 @@ def _cpg_target(entry: _SymbolEntry) -> CpgTarget:
     )
 
 
+def _relation_target(entry: _SymbolEntry) -> RelationTarget:
+    return RelationTarget(
+        target_id=entry.target_id,
+        source_path=str(entry.source_path),
+        path=entry.path,
+        unit_id=entry.unit_id,
+        unit_name=entry.unit_name,
+        name=entry.name,
+        qualified_name=entry.qualified_name,
+        kind=entry.kind.value,
+        signature=entry.signature,
+        line=entry.line,
+        column=entry.column,
+        card={},
+        visibility=entry.visibility.value,
+        type_name=entry.type_name,
+        owner=entry.owner,
+    )
+
+
 class AgentContext:
     def __init__(
         self,
@@ -875,8 +896,15 @@ class AgentContext:
         self._revision_epoch += 1
         self._last_revision_check_at = float("-inf")
 
-    def handle(self, request: AgentRequest | Mapping[str, object]) -> AgentResponse:
+    def handle(
+        self,
+        request: AgentRequest | Mapping[str, object],
+        *,
+        cancel_check: Callable[[], None] | None = None,
+    ) -> AgentResponse:
         parsed = _validated_request(request)
+        if cancel_check is not None:
+            cancel_check()
         revision = self._refresh_workspace(parsed.project_id)
 
         if parsed.action == "cpg":
@@ -890,13 +918,57 @@ class AgentContext:
                 target_id=entry.target_id,
             )
         if parsed.action == "trace":
+            if cancel_check is not None:
+                cancel_check()
             if parsed.relation is None:
                 raise AgentProtocolError("relation_required", "Trace requires a relation.")
-            registry = self._require_registry(revision)
-            entry = self._resolve_target(registry, parsed.target_id)
-            relation_index = self._require_relation_index(registry, parsed.relation)
-            items = relation_index.trace(entry.target_id, parsed.relation)
-            return self._response(parsed, revision, items, target_id=entry.target_id)
+            targeted_references = (
+                parsed.relation == "references"
+                and len(self._workspace.units) >= 256
+            )
+            relation_index = (
+                self._relation_index
+                if (
+                    targeted_references
+                    and self._relation_index is not None
+                    and self._relation_index.project_id
+                    == self._workspace.active_project_id
+                    and self._relation_index.revision == revision
+                    and self._relation_index.has_target(parsed.target_id)
+                )
+                else None
+            )
+            resolved_target_id = parsed.target_id
+            if relation_index is None:
+                registry = self._require_registry(revision)
+                entry = self._resolve_target(registry, parsed.target_id)
+                resolved_target_id = entry.target_id
+                if targeted_references:
+                    relation_index = self._require_reference_relation_index(
+                        registry,
+                        entry,
+                    )
+                    registry.sources.clear_loaded()
+                    self._registry = None
+                    del registry
+                    gc.collect()
+                else:
+                    relation_index = self._require_relation_index(
+                        registry,
+                        parsed.relation,
+                    )
+            items = relation_index.trace(
+                resolved_target_id,
+                parsed.relation,
+                cancel_check=cancel_check,
+                max_relations=parsed.max_items,
+            )
+            return self._response(
+                parsed,
+                revision,
+                items,
+                target_id=resolved_target_id,
+            )
         if parsed.action == "open":
             items = self._open_items()
             return self._response(parsed, revision, items)
@@ -1265,23 +1337,7 @@ class AgentContext:
         ):
             return self._relation_index
         targets = tuple(
-            RelationTarget(
-                target_id=entry.target_id,
-                source_path=str(entry.source_path),
-                path=entry.path,
-                unit_id=entry.unit_id,
-                unit_name=entry.unit_name,
-                name=entry.name,
-                qualified_name=entry.qualified_name,
-                kind=entry.kind.value,
-                signature=entry.signature,
-                line=entry.line,
-                column=entry.column,
-                card={},
-                visibility=entry.visibility.value,
-                type_name=entry.type_name,
-                owner=entry.owner,
-            )
+            _relation_target(entry)
             for entry in registry.entries
             if requires_complete_targets or entry.kind == SymbolKind.UNIT
         )
@@ -1294,6 +1350,32 @@ class AgentContext:
         )
         return self._relation_index
 
+    def _require_reference_relation_index(
+        self,
+        registry: _Registry,
+        entry: _SymbolEntry,
+    ) -> ProjectRelationIndex:
+        if (
+            self._relation_index is not None
+            and self._relation_index.project_id == registry.project_id
+            and self._relation_index.revision == registry.revision
+            and self._relation_index.has_target(entry.target_id)
+        ):
+            return self._relation_index
+        targets = tuple(
+            _relation_target(candidate)
+            for candidate in registry.entries
+            if candidate.source_path == entry.source_path
+        )
+        self._relation_index = ProjectRelationIndex(
+            self._workspace,
+            registry.project_id,
+            registry.revision,
+            targets,
+            targets_complete=False,
+        )
+        return self._relation_index
+
     def _require_selected_project(self) -> str:
         project_id = self._workspace.active_project_id
         if not project_id: