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

delphi_lsp/_version.py

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

delphi_lsp/agent_cache.py

@@ -54,6 +54,7 @@ _WATCHER_READY_TIMEOUT_SECONDS = 1.0
 _WATCHER_READY_POLL_MILLISECONDS = 50
 _STOP_TIMEOUT_SECONDS = 15.0
 _STOP_SIGNAL_DELAY_SECONDS = 3.0
+_STOP_FORCE_TIMEOUT_SECONDS = 2.0
 _WATCHED_SUFFIXES = frozenset(
     {".pas", ".pp", ".inc", ".dpr", ".dpk", ".dproj", ".cfg"}
 )
@@ -365,9 +366,12 @@ class _RequestGuard:
         self,
         service: _CacheService,
         connection: socket.socket,
+        *,
+        enforce_rss_budget: bool = True,
     ) -> None:
         self._service = service
         self._connection = connection
+        self._enforce_rss_budget = enforce_rss_budget
 
     def check(self) -> None:
         if self._service.shutdown.is_set():
@@ -394,14 +398,14 @@ class _RequestGuard:
                 "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
+            self._enforce_rss_budget
+            and self._service._measure_retained_bytes()
+            > self._service.metadata.max_memory_bytes
         ):
             raise CacheClientError(
                 "memory_budget_exceeded",
-                "Cache request exceeded the configured RSS memory budget.",
+                "Cache request exceeded the configured retained-memory budget.",
             )
 
 
@@ -854,11 +858,15 @@ class _CacheService:
         context = self._initialize_context()
         try:
             self.last_revision = context.prewarm_navigation()
-            self.cache_state = "warm"
         except AgentProtocolError as error:
             if error.code != "project_required":
                 raise
-            self.cache_state = "ready"
+        prewarm_rss = current_process_rss_bytes()
+        if prewarm_rss > 0:
+            # Parsing can leave a high allocator RSS watermark even though the
+            # retained navigation data is already covered by its own estimate.
+            # Track only subsequent, otherwise unaccounted-for RSS growth.
+            self._rss_baseline_bytes = prewarm_rss
         self._enforce_budget()
         self.prewarm_seconds = time.monotonic() - started
         self.stats.parallel_fallbacks = context.parallel_stats.fallbacks
@@ -921,58 +929,86 @@ class _CacheService:
             self.context.invalidate_revision_cache()
         with self._request_state_lock:
             self._active_requests += 1
+        lock_acquired = False
         try:
-            with self.lock:
-                self.last_activity = time.monotonic()
-                before = self.last_revision
-                was_warm = self.context.navigation_cache_is_warm
+            while not self.lock.acquire(timeout=0.05):
+                if self.shutdown.is_set():
+                    raise CacheClientError(
+                        "request_cancelled",
+                        "Cache request was cancelled.",
+                    )
+                if cancel_check is not None:
+                    cancel_check()
+            lock_acquired = True
+            if self.shutdown.is_set():
+                raise CacheClientError(
+                    "request_cancelled",
+                    "Cache request was cancelled.",
+                )
+            if cancel_check is not None:
+                cancel_check()
+            self.last_activity = time.monotonic()
+            before = self.last_revision
+            was_warm = self.context.navigation_cache_is_warm
+            request_aborted = False
+            try:
                 try:
-                    try:
-                        handled = (
-                            self.context.handle(request)
-                            if cancel_check is None
-                            else self.context.handle(
-                                request,
-                                cancel_check=cancel_check,
-                            )
+                    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:
+                    )
+                    if self.shutdown.is_set():
                         raise CacheClientError(
-                            "internal_error",
-                            "Internal cache error.",
-                        ) from None
-                finally:
+                            "request_cancelled",
+                            "Cache request was cancelled.",
+                        )
+                    if cancel_check is not None:
+                        cancel_check()
+                    response = handled.to_mapping()
+                except CacheClientError:
+                    request_aborted = True
+                    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:
+                if not request_aborted and not self.shutdown.is_set():
                     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(),
+            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:
+            if lock_acquired:
+                self.lock.release()
             with self._request_state_lock:
                 self._active_requests -= 1
 
@@ -1142,10 +1178,11 @@ def _serve_connection(connection: socket.socket, service: _CacheService) -> None
             response: dict[str, object] = {"error": {"code": "authentication_failed", "message": "authentication failed"}}
         else:
             try:
-                guard = (
-                    _RequestGuard(service, connection)
-                    if request.get("action") in {"trace", "cpg"}
-                    else None
+                action = request.get("action")
+                guard = None if action in {"status", "stop"} else _RequestGuard(
+                    service,
+                    connection,
+                    enforce_rss_budget=action in {"trace", "cpg"},
                 )
                 result = service.request(
                     request,
@@ -1476,6 +1513,24 @@ def stop_cache(root: str | Path) -> None:
                 os.kill(metadata.pid, signal.SIGTERM)
             signal_sent = True
         time.sleep(0.05)
+    if not stopped and _pid_alive(metadata.pid):
+        current = _read_metadata(root)
+        if current == metadata:
+            force_signal = (
+                signal.SIGKILL
+                if os.name != "nt" and hasattr(signal, "SIGKILL")
+                else signal.SIGTERM
+            )
+            with contextlib.suppress(OSError):
+                os.kill(metadata.pid, force_signal)
+            force_deadline = time.monotonic() + _STOP_FORCE_TIMEOUT_SECONDS
+            while time.monotonic() < force_deadline:
+                if _reap_child_if_exited(metadata.pid) or not _pid_alive(
+                    metadata.pid
+                ):
+                    stopped = True
+                    break
+                time.sleep(0.05)
     if not stopped and _pid_alive(metadata.pid):
         raise CacheClientError("stop_failed", "Cache daemon did not stop.")
     _remove_metadata_if_owned(metadata)

delphi_lsp/agent_cli.py

@@ -27,6 +27,7 @@ from .agent_cache import (
 from .agent_context import AgentContext
 from .agent_layers import (
     build_codebase_index,
+    build_metrics_payload,
     build_references_payload,
     layer_payload,
     render_layer,
@@ -45,6 +46,12 @@ from .agent_templates import install_opencode_support, install_skill
 from .agent_wiki import WikiExportError, WikiProgressEvent, export_okf_wiki
 from .parallel_outline import ParallelOutlineError, parse_worker_setting
 from .project_config import ProjectConfigError
+from .response_cache import (
+    ResponseCacheKey,
+    ResponseCacheStore,
+    WorkspaceContentSnapshot,
+    workspace_content_snapshot,
+)
 
 _MAX_WORKER_RECORD_BYTES = 1024 * 1024
 _INVALID_JSON_MESSAGE = "Invalid JSON request."
@@ -323,6 +330,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)
+    store, cache_key, snapshot = _batch_response_cache(
+        args,
+        command="view",
+        layer=args.layer,
+        query=args.query,
+        output_format=args.format,
+    )
+    cached = store.load(cache_key)
+    if cached is not None:
+        sys.stdout.write(cached.decode("utf-8"))
+        return
     if args.layer == "references":
         payload = build_references_payload(
             args.root,
@@ -330,40 +348,112 @@ def _view(args: argparse.Namespace) -> None:
             project_file=args.project_file,
             workers=args.workers,
         )
-        sys.stdout.write(
-            render_payload(payload, output_format=args.format)
+        rendered = render_payload(payload, output_format=args.format)
+    elif args.layer == "metrics":
+        payload = build_metrics_payload(
+            args.root,
+            query=args.query,
+            project_file=args.project_file,
+            workers=args.workers,
+            discovery=snapshot.discovery,
         )
-        return
-    index = build_codebase_index(
-        args.root,
-        project_file=args.project_file,
-        index_projects=args.deep_projects,
-        workers=args.workers,
-    )
-    sys.stdout.write(render_layer(index, args.layer, query=args.query, output_format=args.format))
+        if args.format == "json":
+            rendered = _json_text(payload)
+        else:
+            rendered = render_payload(payload, output_format=args.format)
+    else:
+        index = build_codebase_index(
+            args.root,
+            project_file=args.project_file,
+            index_projects=args.deep_projects,
+            workers=args.workers,
+            use_artifact_cache=False,
+            discovery=snapshot.discovery,
+        )
+        rendered = render_layer(
+            index,
+            args.layer,
+            query=args.query,
+            output_format=args.format,
+        )
+    encoded = rendered.encode("utf-8")
+    _store_batch_response(store, cache_key, encoded)
+    sys.stdout.write(rendered)
 
 
 def _index(args: argparse.Namespace) -> None:
     args.root = _workspace_root(args.root)
     args.project_file = _project_file(args.root, args.project_file)
     output = _resolve_output_path(args.root, args.out)
-    index = build_codebase_index(
-        args.root,
-        project_file=args.project_file,
-        index_projects=args.deep_projects,
-        workers=args.workers,
+    store, cache_key, snapshot = _batch_response_cache(
+        args,
+        command="index",
+        layer="",
+        query="",
+        output_format="json",
     )
-    payload = {
-        "deep_projects": bool(args.deep_projects),
-        "overview": layer_payload(index, "overview"),
-        "projects": layer_payload(index, "projects"),
-        "problems": layer_payload(index, "problems"),
-    }
+    encoded = store.load(cache_key)
+    if encoded is None:
+        index = build_codebase_index(
+            args.root,
+            project_file=args.project_file,
+            index_projects=args.deep_projects,
+            workers=args.workers,
+            use_artifact_cache=False,
+            discovery=snapshot.discovery,
+        )
+        payload = {
+            "deep_projects": bool(args.deep_projects),
+            "overview": layer_payload(index, "overview"),
+            "projects": layer_payload(index, "projects"),
+            "problems": layer_payload(index, "problems"),
+        }
+        encoded = (json.dumps(payload, indent=2, sort_keys=True) + "\n").encode(
+            "utf-8"
+        )
+        _store_batch_response(store, cache_key, encoded)
     output.parent.mkdir(parents=True, exist_ok=True)
-    output.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    output.write_bytes(encoded)
     print(output)
 
 
+def _batch_response_cache(
+    args: argparse.Namespace,
+    *,
+    command: str,
+    layer: str,
+    query: str,
+    output_format: str,
+) -> tuple[ResponseCacheStore, ResponseCacheKey, WorkspaceContentSnapshot]:
+    snapshot = workspace_content_snapshot(
+        args.root,
+        project_file=args.project_file,
+    )
+    return (
+        ResponseCacheStore(args.root / ".delphi-lsp" / "response-cache"),
+        ResponseCacheKey(
+            workspace_revision=snapshot.revision,
+            command=command,
+            layer=layer,
+            query=query,
+            output_format=output_format,
+            deep_projects=bool(args.deep_projects),
+        ),
+        snapshot,
+    )
+
+
+def _store_batch_response(
+    store: ResponseCacheStore,
+    key: ResponseCacheKey,
+    payload: bytes,
+) -> None:
+    try:
+        store.store(key, payload)
+    except (OSError, ValueError):
+        pass
+
+
 def _wiki_export(args: argparse.Namespace) -> None:
     args.root = _workspace_root(args.root)
     args.project_file = _project_file(args.root, args.project_file)
@@ -518,7 +608,11 @@ def _open_worker_context(
 
 
 def _write_json(payload: object) -> None:
-    sys.stdout.write(json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n")
+    sys.stdout.write(_json_text(payload))
+
+
+def _json_text(payload: object) -> str:
+    return json.dumps(payload, sort_keys=True, separators=(",", ":")) + "\n"
 
 
 def _write_warning(warning: str) -> None: