python-delphi-lsp 2.0.4__py3-none-any.whl → 2.0.5__py3-none-any.whl

delphi_lsp/_version.py

@@ -1 +1 @@
-__version__ = "2.0.4"
+__version__ = "2.0.5"

delphi_lsp/agent_cache.py

@@ -0,0 +1,710 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Collection, Mapping
+from dataclasses import dataclass, fields, is_dataclass, replace
+import argparse
+import contextlib
+import hmac
+import json
+import os
+from pathlib import Path
+import secrets
+import socket
+import stat
+import subprocess
+import sys
+import re
+import tempfile
+import threading
+import time
+from types import ModuleType
+
+from ._version import __version__
+from .agent_context import AgentContext
+from .agent_protocol import AgentProtocolError
+
+
+DEFAULT_MAX_MEMORY_BYTES = 512 * 1024**2
+WARNING_THRESHOLD_PERCENT = 80
+DAEMON_SCHEMA = 1
+DEFAULT_IDLE_TIMEOUT = 1800
+_MAX_MESSAGE_BYTES = 1024 * 1024
+_CONNECTION_TIMEOUT = 2.0
+_MEMORY_SIZE = re.compile(r"^(?P<count>[1-9][0-9]*)(?P<suffix>[KMG]?)$", re.IGNORECASE)
+_STARTUP_DIAGNOSTIC_BYTES = 16 * 1024
+_STARTUP_TOKEN_RE = re.compile(r"(?i)(token\b[^\n\r]*?:?\s*['\"]?[A-Za-z0-9_-]+['\"]?|\b[a-zA-Z0-9_-]{32,})")
+
+
+def estimate_deep_size(value: object) -> int:
+    """Estimate the memory retained by an owned object graph.
+
+    The traversal is intentionally best-effort: unsupported or opaque values
+    still count themselves, but do not cause cache accounting to fail.
+    """
+    total = 0
+    seen: set[int] = set()
+    pending: list[object] = [value]
+
+    while pending:
+        current = pending.pop()
+        if isinstance(current, (ModuleType, type)) or callable(current):
+            continue
+        identifier = id(current)
+        if identifier in seen:
+            continue
+        seen.add(identifier)
+        try:
+            total += sys.getsizeof(current)
+        except Exception:
+            pass
+
+        try:
+            pending.extend(_children(current))
+        except Exception:
+            continue
+    return total
+
+
+@dataclass
+class CacheStats:
+    requests: int = 0
+    warm_hits: int = 0
+    rebuilds: int = 0
+    invalidations: int = 0
+    evictions: int = 0
+
+
+@dataclass(frozen=True)
+class BudgetResult:
+    retained_bytes: int
+    utilization_percent: float
+    peak_utilization_percent: float
+    warning_active: bool
+    warning_triggered: bool
+    compacted: bool
+
+
+@dataclass(frozen=True)
+class CacheBudget:
+    max_bytes: int = DEFAULT_MAX_MEMORY_BYTES
+    warning_percent: int = WARNING_THRESHOLD_PERCENT
+
+    def __post_init__(self) -> None:
+        if self.max_bytes <= 0:
+            raise ValueError("max_bytes must be greater than zero.")
+        if not 0 < self.warning_percent <= 100:
+            raise ValueError("warning_percent must be between 1 and 100.")
+
+    def enforce(
+        self,
+        *,
+        measure: Callable[[], int],
+        evict_auxiliary: Callable[[], None],
+        evict_navigation: Callable[[], None],
+    ) -> BudgetResult:
+        initial_retained = measure()
+        initial_utilization_percent = initial_retained * 100.0 / self.max_bytes
+        compacted = False
+        retained = initial_retained
+
+        if initial_retained > self.max_bytes:
+            evict_auxiliary()
+            compacted = True
+            retained = measure()
+            if retained > self.max_bytes:
+                evict_navigation()
+                retained = measure()
+
+        current_utilization_percent = retained * 100.0 / self.max_bytes
+        return BudgetResult(
+            retained_bytes=retained,
+            utilization_percent=current_utilization_percent,
+            peak_utilization_percent=initial_utilization_percent,
+            warning_active=current_utilization_percent >= self.warning_percent,
+            warning_triggered=initial_utilization_percent >= self.warning_percent,
+            compacted=compacted,
+        )
+
+
+def parse_memory_size(value: str) -> int:
+    match = _MEMORY_SIZE.fullmatch(value.strip())
+    if match is None:
+        raise ValueError("Memory size must be a positive integer with optional K, M, or G suffix.")
+
+    multiplier = {
+        "": 1,
+        "K": 1024,
+        "M": 1024**2,
+        "G": 1024**3,
+    }
+    return int(match.group("count")) * multiplier[match.group("suffix").upper()]
+
+
+def cache_warning(result: BudgetResult, max_bytes: int) -> str:
+    if not result.warning_triggered:
+        return ""
+
+    if result.compacted:
+        state = (
+            f"Warning: Delphi cache peaked at {result.peak_utilization_percent:.1f}% of the {max_bytes} byte budget; "
+            f"{result.retained_bytes} bytes remain retained after compaction."
+            f"{' Cache compacted.' if result.compacted else ''}"
+        )
+    else:
+        state = (
+            f"Warning: Delphi cache currently at {result.utilization_percent:.1f}% of the {max_bytes} byte budget; "
+            f"{result.retained_bytes} bytes retained."
+        )
+    return (
+        f"{state} "
+        "Increase --max-memory, stop unused daemons, or allow compact mode."
+    )
+
+
+def _children(value: object) -> tuple[object, ...]:
+    children: list[object] = []
+    if isinstance(value, Mapping):
+        try:
+            for key, item in value.items():
+                children.extend((key, item))
+        except Exception:
+            pass
+    elif isinstance(value, Collection) and not isinstance(value, (str, bytes, bytearray)):
+        try:
+            children.extend(value)
+        except Exception:
+            pass
+
+    is_dataclass_instance = is_dataclass(value) and not isinstance(value, type)
+    dataclass_field_names: frozenset[str] = frozenset()
+    if is_dataclass_instance:
+        try:
+            dataclass_fields = fields(value)
+        except Exception:
+            dataclass_fields = ()
+        dataclass_field_names = frozenset(field.name for field in dataclass_fields)
+        for field in dataclass_fields:
+            try:
+                children.append(getattr(value, field.name))
+            except Exception:
+                continue
+    else:
+        try:
+            instance_values = vars(value)
+        except Exception:
+            instance_values = None
+        if isinstance(instance_values, Mapping):
+            children.extend(instance_values.values())
+
+    for slot in _slot_names(type(value)):
+        if slot in dataclass_field_names:
+            continue
+        try:
+            children.append(getattr(value, slot))
+        except Exception:
+            continue
+    return tuple(children)
+
+
+def _slot_names(value_type: type[object]) -> tuple[str, ...]:
+    names: list[str] = []
+    for base in value_type.__mro__:
+        try:
+            slots = getattr(base, "__slots__", ())
+        except Exception:
+            continue
+        if isinstance(slots, str):
+            slots = (slots,)
+        try:
+            names.extend(name for name in slots if isinstance(name, str))
+        except Exception:
+            continue
+    return tuple(names)
+
+
+@dataclass(frozen=True)
+class CacheMetadata:
+    schema: int
+    root: str
+    pid: int
+    port: int
+    token: str
+    version: str
+    project_file: str
+    max_memory_bytes: int
+    idle_timeout: int
+    started_at: float
+
+
+@dataclass(frozen=True)
+class CacheClientResponse:
+    payload: dict[str, object]
+    warning: str = ""
+
+
+class CacheClientError(RuntimeError):
+    def __init__(self, code: str, message: str) -> None:
+        self.code = code
+        self.message = message
+        super().__init__(message)
+
+
+def cache_metadata_path(root: str | Path) -> Path:
+    return Path(root).resolve() / ".delphi-lsp" / "agent-cache" / "daemon.json"
+
+
+def _safe_metadata_path(root: str | Path, *, create: bool = False) -> Path:
+    root_path = Path(root).resolve()
+    for path in (root_path / ".delphi-lsp", root_path / ".delphi-lsp" / "agent-cache"):
+        if path.exists() and path.is_symlink():
+            raise CacheClientError("unsafe_metadata", "Cache metadata path is unsafe.")
+        if create:
+            path.mkdir(mode=0o700, exist_ok=True)
+            if os.name != "nt":
+                os.chmod(path, 0o700)
+    result = root_path / ".delphi-lsp" / "agent-cache" / "daemon.json"
+    if result.exists() and result.is_symlink():
+        raise CacheClientError("unsafe_metadata", "Cache metadata path is unsafe.")
+    return result
+
+
+def _metadata_mapping(metadata: CacheMetadata) -> dict[str, object]:
+    return {field.name: getattr(metadata, field.name) for field in fields(metadata)}
+
+
+def _write_metadata(metadata: CacheMetadata) -> None:
+    path = _safe_metadata_path(metadata.root, create=True)
+    data = json.dumps(_metadata_mapping(metadata), sort_keys=True, separators=(",", ":")).encode("utf-8")
+    descriptor, temporary = tempfile.mkstemp(prefix=".daemon-", dir=path.parent)
+    try:
+        if os.name != "nt":
+            os.fchmod(descriptor, 0o600)
+        with os.fdopen(descriptor, "wb") as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temporary, path)
+        if os.name != "nt":
+            os.chmod(path, 0o600)
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(temporary)
+
+
+def _read_metadata(root: str | Path) -> CacheMetadata | None:
+    path = _safe_metadata_path(root)
+    if not path.exists():
+        return None
+    try:
+        flags = os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0)
+        descriptor = os.open(path, flags)
+        try:
+            info = os.fstat(descriptor)
+            if os.name != "nt" and (not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid() or info.st_mode & 0o077):
+                raise CacheClientError("unsafe_metadata", "Cache metadata path is unsafe.")
+            raw = json.loads(os.read(descriptor, _MAX_MESSAGE_BYTES).decode("utf-8"))
+        finally:
+            os.close(descriptor)
+    except CacheClientError:
+        raise
+    except (OSError, ValueError, UnicodeError):
+        return None
+    required = {field.name for field in fields(CacheMetadata)}
+    if not isinstance(raw, dict) or set(raw) != required:
+        return None
+    values = tuple(raw[name] for name in ("schema", "root", "pid", "port", "token", "version", "project_file", "max_memory_bytes", "idle_timeout", "started_at"))
+    if (type(values[0]) is not int or values[0] != DAEMON_SCHEMA or not isinstance(values[1], str)
+            or type(values[2]) is not int or values[2] <= 0 or type(values[3]) is not int or not 0 < values[3] < 65536
+            or not isinstance(values[4], str) or len(values[4]) < 32 or not isinstance(values[5], str)
+            or not isinstance(values[6], str) or type(values[7]) is not int or values[7] <= 0
+            or type(values[8]) is not int or values[8] <= 0 or type(values[9]) not in (int, float)):
+        return None
+    canonical = str(Path(root).resolve())
+    if values[1] != canonical:
+        return None
+    return CacheMetadata(*values)
+
+
+def _remove_metadata_if_owned(metadata: CacheMetadata) -> None:
+    path = _safe_metadata_path(metadata.root)
+    current = _read_metadata(metadata.root)
+    if current is not None and current.pid == metadata.pid and hmac.compare_digest(current.token, metadata.token):
+        with contextlib.suppress(FileNotFoundError):
+            path.unlink()
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except OSError:
+        return False
+    return True
+
+
+def _start_lock_path(root: str | Path) -> Path:
+    return _safe_metadata_path(root, create=True).with_name("start.lock")
+
+
+@contextlib.contextmanager
+def _start_lock(root: str | Path):
+    path = _start_lock_path(root)
+    token = secrets.token_urlsafe(24)
+    deadline = time.monotonic() + 10
+    while True:
+        try:
+            descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+            try:
+                payload = json.dumps({"pid": os.getpid(), "token": token, "started_at": time.time()}).encode("utf-8")
+                os.write(descriptor, payload)
+                os.fsync(descriptor)
+            finally:
+                os.close(descriptor)
+            break
+        except FileExistsError:
+            try:
+                record = json.loads(path.read_text(encoding="utf-8"))
+                owner = record.get("pid") if isinstance(record, dict) else None
+                started = record.get("started_at") if isinstance(record, dict) else None
+                stale = type(owner) is not int or not _pid_alive(owner) or type(started) not in (int, float) or time.time() - started > 30
+            except (OSError, ValueError, UnicodeError):
+                stale = True
+            if stale:
+                with contextlib.suppress(FileNotFoundError):
+                    path.unlink()
+                continue
+            if time.monotonic() >= deadline:
+                raise CacheClientError("startup_locked", "Cache startup is busy.")
+            time.sleep(0.05)
+    try:
+        yield
+    finally:
+        try:
+            current = json.loads(path.read_text(encoding="utf-8"))
+            if isinstance(current, dict) and hmac.compare_digest(str(current.get("token", "")), token):
+                path.unlink()
+        except (OSError, ValueError, UnicodeError):
+            pass
+
+
+def _client_exchange(metadata: CacheMetadata, request: dict[str, object]) -> CacheClientResponse:
+    try:
+        with socket.create_connection(("127.0.0.1", metadata.port), timeout=2) as connection:
+            connection.settimeout(3)
+            request_without_token = {key: value for key, value in request.items() if key != "token"}
+            connection.sendall(json.dumps({"token": metadata.token, **request_without_token}, separators=(",", ":")).encode("utf-8") + b"\n")
+            response = _read_line(connection)
+    except OSError as error:
+        raise CacheClientError("unavailable", "Cache daemon is unavailable.") from error
+    try:
+        decoded = json.loads(response.decode("utf-8"))
+    except (UnicodeError, ValueError) as error:
+        raise CacheClientError("invalid_response", "Cache daemon returned an invalid response.") from error
+    if not isinstance(decoded, dict):
+        raise CacheClientError("invalid_response", "Cache daemon returned an invalid response.")
+    if "error" in decoded:
+        error = decoded["error"]
+        if isinstance(error, dict):
+            raise CacheClientError(str(error.get("code", "error")), str(error.get("message", "Cache request failed.")))
+        raise CacheClientError("error", "Cache request failed.")
+    payload = decoded.get("payload")
+    if not isinstance(payload, dict):
+        raise CacheClientError("invalid_response", "Cache daemon returned an invalid response.")
+    return CacheClientResponse(payload, str(decoded.get("warning", "")))
+
+
+def _read_line(connection: socket.socket) -> bytes:
+    chunks = bytearray()
+    while len(chunks) <= _MAX_MESSAGE_BYTES:
+        piece = connection.recv(min(65536, _MAX_MESSAGE_BYTES + 1 - len(chunks)))
+        if not piece:
+            break
+        chunks.extend(piece)
+        if b"\n" in piece:
+            line, _, _ = chunks.partition(b"\n")
+            return line
+    raise CacheClientError("invalid_response", "Cache daemon returned an invalid response.")
+
+
+def _truncate_and_sanitize_startup_diagnostics(raw: bytes, *, max_bytes: int = _STARTUP_DIAGNOSTIC_BYTES) -> str:
+    if not raw:
+        return ""
+    text = raw.decode("utf-8", "replace")
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    if max_bytes > 0 and len(text) > max_bytes:
+        text = text[-max_bytes:]
+    text = re.sub(r"[\x00-\x09\x0b-\x1f\x7f-\x9f]", " ", text)
+    text = _STARTUP_TOKEN_RE.sub("<redacted>", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def _read_startup_tail(diagnostics: object, *, max_bytes: int = _STARTUP_DIAGNOSTIC_BYTES) -> bytes:
+    with contextlib.suppress(Exception):
+        diagnostics.seek(0, os.SEEK_END)
+        end = diagnostics.tell()
+        diagnostics.seek(max(0, end - max_bytes), os.SEEK_SET)
+        return diagnostics.read()
+    return b""
+
+
+class _CacheService:
+    def __init__(self, metadata: CacheMetadata) -> None:
+        self.metadata = metadata
+        self.context = AgentContext.open(metadata.root, metadata.project_file or None)
+        self.budget = CacheBudget(metadata.max_memory_bytes)
+        self.stats = CacheStats()
+        self.lock = threading.Lock()
+        self.started = time.monotonic()
+        self.last_activity = self.started
+        self.cache_state = "warming"
+        self.last_revision = self.context.workspace.workspace_revision
+        self.last_budget = BudgetResult(0, 0.0, 0.0, False, False, False)
+        self.shutdown = threading.Event()
+
+    def prewarm(self) -> None:
+        try:
+            self.context.handle({"action": "find", "query": "", "max_items": 1, "max_chars": 256})
+            self.last_revision = self.context.workspace.workspace_revision
+            self.cache_state = "warm"
+        except AgentProtocolError as error:
+            if error.code != "project_required":
+                raise
+            self.cache_state = "ready"
+        self.last_budget = self.budget.enforce(
+            measure=lambda: estimate_deep_size(self.context.cache_roots()),
+            evict_auxiliary=self.context.evict_auxiliary_caches,
+            evict_navigation=self.context.evict_navigation_caches,
+        )
+        if self.last_budget.compacted:
+            self.stats.evictions += 1
+            self.cache_state = "compact"
+
+    def request(self, request: dict[str, object]) -> CacheClientResponse:
+        with self.lock:
+            action = request.get("action")
+            if action == "status":
+                warning = "" if request.get("_startup_probe") is True else self._consume_warning()
+                return CacheClientResponse(self.status(), warning)
+            if action == "stop":
+                self.shutdown.set()
+                return CacheClientResponse({"stopping": True})
+            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
+            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
+            if before != after:
+                self.stats.invalidations += 1
+            self.last_budget = self.budget.enforce(
+                measure=lambda: estimate_deep_size(self.context.cache_roots()),
+                evict_auxiliary=self.context.evict_auxiliary_caches,
+                evict_navigation=self.context.evict_navigation_caches,
+            )
+            if self.last_budget.compacted:
+                self.stats.evictions += 1
+                self.cache_state = "compact"
+            else:
+                self.cache_state = "warm" if self.context.navigation_cache_is_warm else "ready"
+            return CacheClientResponse(response, self._consume_warning())
+
+    def _consume_warning(self) -> str:
+        warning = cache_warning(self.last_budget, self.budget.max_bytes)
+        if self.last_budget.warning_triggered and not self.last_budget.warning_active:
+            self.last_budget = replace(self.last_budget, warning_triggered=False)
+        return warning
+
+    def status(self) -> dict[str, object]:
+        now = time.monotonic()
+        idle = max(0.0, now - self.last_activity)
+        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,
+            "last_activity_at": time.time() - idle,
+            "max_memory_bytes": self.budget.max_bytes, "current_bytes": self.last_budget.retained_bytes,
+            "current_utilization_percent": self.last_budget.utilization_percent,
+            "peak_utilization_percent": self.last_budget.peak_utilization_percent,
+            "warning_active": self.last_budget.warning_active, "warning_threshold_percent": WARNING_THRESHOLD_PERCENT,
+            "cache_state": self.cache_state, "requests": self.stats.requests, "warm_hits": self.stats.warm_hits,
+            "rebuilds": self.stats.rebuilds, "invalidations": self.stats.invalidations, "evictions": self.stats.evictions,
+            "idle_timeout": self.metadata.idle_timeout, "idle_remaining": max(0.0, self.metadata.idle_timeout - idle),
+            "workspace_revision": self.context.workspace.workspace_revision,
+        }
+
+
+def _serve_connection(connection: socket.socket, service: _CacheService) -> None:
+    try:
+        line = _read_line(connection)
+        request = json.loads(line.decode("utf-8"))
+        if not isinstance(request, dict) or not hmac.compare_digest(str(request.pop("token", "")), service.metadata.token):
+            response: dict[str, object] = {"error": {"code": "authentication_failed", "message": "authentication failed"}}
+        else:
+            try:
+                result = service.request(request)
+                response = {"payload": result.payload, "warning": result.warning}
+            except CacheClientError as error:
+                response = {"error": {"code": error.code, "message": error.message}}
+    except Exception:
+        response = {"error": {"code": "invalid_request", "message": "Invalid cache request."}}
+    with contextlib.suppress(OSError):
+        connection.sendall(json.dumps(response, separators=(",", ":")).encode("utf-8") + b"\n")
+
+
+def run_cache_daemon(root: str | Path, *, project_file: str = "", max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES, idle_timeout: int = DEFAULT_IDLE_TIMEOUT) -> None:
+    canonical = str(Path(root).resolve())
+    listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    listener.bind(("127.0.0.1", 0))
+    listener.listen(16)
+    listener.settimeout(0.25)
+    metadata = CacheMetadata(DAEMON_SCHEMA, canonical, os.getpid(), listener.getsockname()[1], secrets.token_urlsafe(32), __version__, project_file, max_memory_bytes, idle_timeout, time.time())
+    try:
+        service = _CacheService(metadata)
+        service.prewarm()
+        _write_metadata(metadata)
+        while not service.shutdown.is_set() and time.monotonic() - service.last_activity < idle_timeout:
+            try:
+                connection, _ = listener.accept()
+            except socket.timeout:
+                continue
+            with connection:
+                connection.settimeout(_CONNECTION_TIMEOUT)
+                _serve_connection(connection, service)
+    finally:
+        listener.close()
+        _remove_metadata_if_owned(metadata)
+
+
+def _start_cache_unlocked(root: str | Path, *, project_file: str | Path | None = None, max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES, idle_timeout: int = DEFAULT_IDLE_TIMEOUT) -> CacheMetadata:
+    canonical = str(Path(root).resolve())
+    project = str((Path(canonical) / project_file).resolve()) if project_file and not Path(project_file).is_absolute() else (str(Path(project_file).resolve()) if project_file else "")
+    existing = _read_metadata(canonical)
+    if existing and _pid_alive(existing.pid):
+        try:
+            _client_exchange(existing, {"action": "status", "_startup_probe": True})
+        except CacheClientError as error:
+            raise CacheClientError("unavailable", "Live cache daemon is unavailable.") from error
+        if (existing.project_file, existing.max_memory_bytes, existing.idle_timeout) != (project, max_memory_bytes, idle_timeout):
+            raise CacheClientError("configuration_conflict", "A live cache daemon has conflicting configuration.")
+        return existing
+    if existing:
+        _remove_metadata_if_owned(existing)
+    command = [sys.executable, "-m", "delphi_lsp.agent_cache", "serve", "--root", canonical, "--max-memory", str(max_memory_bytes), "--idle-timeout", str(idle_timeout)]
+    if project:
+        command.extend(("--project-file", project))
+    options: dict[str, object] = {"stdin": subprocess.DEVNULL, "stdout": subprocess.DEVNULL}
+    if os.name == "nt":
+        options["creationflags"] = subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP
+    else:
+        options["start_new_session"] = True
+    with tempfile.TemporaryFile() as diagnostics:
+        options["stderr"] = diagnostics
+        process = subprocess.Popen(command, **options)
+        deadline = time.monotonic() + 10
+        startup_ready = False
+        try:
+            while time.monotonic() < deadline:
+                metadata = _read_metadata(canonical)
+                if metadata:
+                    try:
+                        _client_exchange(metadata, {"action": "status", "_startup_probe": True})
+                        startup_ready = True
+                        return metadata
+                    except CacheClientError:
+                        pass
+                if process.poll() is not None:
+                    break
+                time.sleep(0.05)
+            if process.poll() is None:
+                process.kill()
+            with contextlib.suppress(Exception):
+                process.wait()
+            metadata = _read_metadata(canonical)
+            if metadata and metadata.pid == process.pid:
+                _remove_metadata_if_owned(metadata)
+            diagnostics.seek(0)
+            raw = _read_startup_tail(diagnostics)
+            message = _truncate_and_sanitize_startup_diagnostics(raw)
+            base = "Cache daemon did not become ready."
+            if message:
+                raise CacheClientError("startup_failed", f"{base} {message}")
+            raise CacheClientError("startup_failed", base)
+        finally:
+            if not startup_ready:
+                if process.poll() is None:
+                    process.kill()
+                with contextlib.suppress(Exception):
+                    process.wait()
+
+
+def start_cache(root: str | Path, *, project_file: str | Path | None = None, max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES, idle_timeout: int = DEFAULT_IDLE_TIMEOUT) -> CacheMetadata:
+    with _start_lock(root):
+        return _start_cache_unlocked(root, project_file=project_file, max_memory_bytes=max_memory_bytes, idle_timeout=idle_timeout)
+
+
+def query_cache(root: str | Path, request: dict[str, object]) -> CacheClientResponse:
+    metadata = _read_metadata(root)
+    if metadata is None:
+        raise CacheClientError("cache_not_running", "Cache daemon is not running.")
+    if not _pid_alive(metadata.pid):
+        _remove_metadata_if_owned(metadata)
+        raise CacheClientError("cache_not_running", "Cache daemon is not running.")
+    return _client_exchange(metadata, request)
+
+
+def cache_status(root: str | Path) -> dict[str, object]:
+    return query_cache(root, {"action": "status"}).payload
+
+
+def stop_cache(root: str | Path) -> None:
+    metadata = _read_metadata(root)
+    if metadata is None:
+        return
+    if not _pid_alive(metadata.pid):
+        _remove_metadata_if_owned(metadata)
+        return
+    try:
+        _client_exchange(metadata, {"action": "stop"})
+    except CacheClientError:
+        pass
+    deadline = time.monotonic() + 3
+    stopped = False
+    while _pid_alive(metadata.pid) and time.monotonic() < deadline:
+        with contextlib.suppress(ChildProcessError):
+            if os.waitpid(metadata.pid, os.WNOHANG)[0] == 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)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    command = parser.add_subparsers(dest="command", required=True)
+    serve = command.add_parser("serve")
+    serve.add_argument("--root", required=True)
+    serve.add_argument("--project-file", default="")
+    serve.add_argument("--max-memory", type=int, default=DEFAULT_MAX_MEMORY_BYTES)
+    serve.add_argument("--idle-timeout", type=int, default=DEFAULT_IDLE_TIMEOUT)
+    args = parser.parse_args(argv)
+    if args.command == "serve":
+        run_cache_daemon(args.root, project_file=args.project_file, max_memory_bytes=args.max_memory, idle_timeout=args.idle_timeout)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

delphi_lsp/agent_cli.py

@@ -8,8 +8,18 @@ from pathlib import Path
 from typing import BinaryIO, TextIO
 
 from .agent_context import AgentContext
+from .agent_cache import (
+    CacheClientError,
+    DEFAULT_IDLE_TIMEOUT,
+    DEFAULT_MAX_MEMORY_BYTES,
+    parse_memory_size,
+    query_cache,
+    run_cache_daemon,
+    start_cache,
+    stop_cache,
+)
 from .agent_layers import build_codebase_index, layer_payload, render_layer
-from .agent_protocol import AgentProtocolError
+from .agent_protocol import AgentProtocolError, SUPPORTED_ACTIONS, SUPPORTED_DETAILS, SUPPORTED_RELATIONS
 from .agent_templates import install_opencode_support, install_skill
 
 
@@ -87,20 +97,58 @@ def build_parser() -> argparse.ArgumentParser:
     worker.add_argument("--project-file", type=Path)
     worker.set_defaults(func=_worker)
 
+    cache = subcommands.add_parser("cache", help="Manage the shared Protocol v2 cache daemon.")
+    cache_commands = cache.add_subparsers(dest="cache_command", required=True)
+    cache_start = cache_commands.add_parser("start", help="Start the cache daemon if needed.")
+    _add_cache_start_arguments(cache_start)
+    cache_start.set_defaults(func=_cache_start)
+    cache_status_parser = cache_commands.add_parser("status", help="Show cache daemon status.")
+    cache_status_parser.add_argument("--root", type=Path, default=Path("."))
+    cache_status_parser.add_argument("--format", choices=["text", "json"], default="text")
+    cache_status_parser.set_defaults(func=_cache_status)
+    cache_stop = cache_commands.add_parser("stop", help="Stop the cache daemon if it is running.")
+    cache_stop.add_argument("--root", type=Path, default=Path("."))
+    cache_stop.set_defaults(func=_cache_stop)
+    cache_serve = cache_commands.add_parser("serve", help=argparse.SUPPRESS)
+    cache_serve.add_argument("--root", type=Path, required=True)
+    cache_serve.add_argument("--project-file", type=Path)
+    cache_serve.add_argument("--max-memory", type=parse_memory_size, required=True)
+    cache_serve.add_argument("--idle-timeout", type=int, required=True)
+    cache_serve.set_defaults(func=_cache_serve)
+
+    query = subcommands.add_parser("query", help="Send an ergonomic request to a running cache daemon.")
+    query.add_argument("--root", type=Path, default=Path("."))
+    query.add_argument("action", choices=SUPPORTED_ACTIONS)
+    query.add_argument("value", nargs="?", default="")
+    query.add_argument("--project-id", default="")
+    query.add_argument("--detail", choices=SUPPORTED_DETAILS, default="summary")
+    query.add_argument("--relation", choices=SUPPORTED_RELATIONS)
+    query.add_argument("--cursor", default="")
+    query.add_argument("--max-items", type=int, default=12)
+    query.add_argument("--max-chars", type=int, default=12000)
+    query.set_defaults(func=_query)
+
     return parser
 
 
+def _add_cache_start_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--root", type=Path, default=Path("."))
+    parser.add_argument("--project-file", type=Path)
+    parser.add_argument("--max-memory", type=parse_memory_size, default=DEFAULT_MAX_MEMORY_BYTES)
+    parser.add_argument("--idle-timeout", type=int, default=DEFAULT_IDLE_TIMEOUT)
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)
     try:
-        args.func(args)
+        result = args.func(args)
         if not getattr(sys.stdout, "closed", False):
             sys.stdout.flush()
     except BrokenPipeError:
         _discard_broken_stdout()
         os._exit(1)
-    return 0
+    return result if isinstance(result, int) else 0
 
 
 def _discard_broken_stdout() -> None:
@@ -169,6 +217,100 @@ def _worker(args: argparse.Namespace) -> None:
             raise BrokenPipeError from error
 
 
+def _write_json(payload: object) -> None:
+    sys.stdout.write(json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n")
+
+
+def _write_warning(warning: str) -> None:
+    if warning:
+        sys.stderr.write(warning + "\n")
+        sys.stderr.flush()
+
+
+def _cache_error(error: CacheClientError) -> int:
+    sys.stderr.write(f"cache_error:{error.code}: {error.message}\n")
+    sys.stderr.flush()
+    return 1
+
+
+def _cache_start(args: argparse.Namespace) -> int:
+    try:
+        start_cache(args.root, project_file=args.project_file, max_memory_bytes=args.max_memory, idle_timeout=args.idle_timeout)
+        response = query_cache(args.root, {"action": "status"})
+    except CacheClientError as error:
+        return _cache_error(error)
+    _write_json(response.payload)
+    _write_warning(response.warning)
+    return 0
+
+
+def _cache_status(args: argparse.Namespace) -> int:
+    try:
+        response = query_cache(args.root, {"action": "status"})
+    except CacheClientError as error:
+        return _cache_error(error)
+    if args.format == "json":
+        _write_json(response.payload)
+    else:
+        status = response.payload
+        sys.stdout.write(
+            f"running pid={status['pid']} state={status['cache_state']} "
+            f"memory={status['current_utilization_percent']:.1f}%\n"
+        )
+    _write_warning(response.warning)
+    return 0
+
+
+def _cache_stop(args: argparse.Namespace) -> int:
+    try:
+        response = query_cache(args.root, {"action": "status"})
+    except CacheClientError as error:
+        if error.code in {"unavailable", "cache_not_running"}:
+            try:
+                stop_cache(args.root)
+            except CacheClientError as cleanup_error:
+                return _cache_error(cleanup_error)
+            _write_json({"stopped": False})
+            return 0
+        return _cache_error(error)
+    _write_warning(response.warning)
+    try:
+        stop_cache(args.root)
+    except CacheClientError as error:
+        return _cache_error(error)
+    _write_json({"stopped": True})
+    return 0
+
+
+def _cache_serve(args: argparse.Namespace) -> int:
+    run_cache_daemon(args.root, project_file=str(args.project_file or ""), max_memory_bytes=args.max_memory, idle_timeout=args.idle_timeout)
+    return 0
+
+
+def _query(args: argparse.Namespace) -> int:
+    request: dict[str, object] = {"action": args.action}
+    if args.value:
+        if args.action in {"find", "metrics"}:
+            request["query"] = args.value
+        elif args.action in {"focus", "inspect", "trace"}:
+            request["target_id"] = args.value
+        else:
+            sys.stderr.write(f"cache_error:invalid_request: {args.action} does not accept a value.\n")
+            sys.stderr.flush()
+            return 1
+    for argument, field in (("project_id", "project_id"), ("detail", "detail"), ("relation", "relation"), ("cursor", "cursor"), ("max_items", "max_items"), ("max_chars", "max_chars")):
+        value = getattr(args, argument)
+        if value is not None:
+            request[field] = value
+    try:
+        response = query_cache(args.root, request)
+    except CacheClientError as error:
+        return _cache_error(error)
+    _write_json(response.payload)
+    _write_warning(response.warning)
+    return 0
+
+
 def _serve_worker(context: AgentContext, input_stream: BinaryIO, output_stream: BinaryIO, error_stream: TextIO) -> None:
     discarding_oversize_record = False
     while True:

delphi_lsp/agent_context.py

@@ -261,6 +261,28 @@ class AgentContext:
     def workspace(self) -> AgentWorkspace:
         return self._workspace
 
+    @property
+    def navigation_cache_is_warm(self) -> bool:
+        return self._registry is not None
+
+    def cache_roots(self) -> tuple[object, ...]:
+        return (
+            *self._workspace.cache_roots(),
+            self._registry,
+            self._relation_index,
+            self._metrics,
+        )
+
+    def evict_auxiliary_caches(self) -> None:
+        self._relation_index = None
+        self._metrics = None
+        self._metrics_revision = ""
+
+    def evict_navigation_caches(self) -> None:
+        self.evict_auxiliary_caches()
+        self._registry = None
+        self._workspace.evict_recomputable_caches()
+
     def handle(self, request: AgentRequest | Mapping[str, object]) -> AgentResponse:
         parsed = _validated_request(request)
         revision = self._refresh_workspace(parsed.project_id)

delphi_lsp/agent_relations.py

@@ -23,7 +23,6 @@ from .semantic import (
     Symbol,
     SymbolIndex,
     SymbolKind,
-    SymbolReference,
     TypeRef,
 )
 from .source_reader import read_source_text

delphi_lsp/agent_workspace.py

@@ -176,6 +176,13 @@ class AgentWorkspace:
     def active_project_id(self) -> str:
         return self._active_project_id
 
+    def cache_roots(self) -> tuple[object, ...]:
+        return (self._project_cache, self._active_result)
+
+    def evict_recomputable_caches(self) -> None:
+        self._project_cache.clear()
+        self._active_result = None
+
     @property
     def focus(self) -> Focus:
         return self._focus

delphi_lsp/binary.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 from enum import IntEnum
 import io
 import struct

delphi_lsp/lsp_server.py

@@ -18,8 +18,6 @@ from .semantic import (
     SymbolKind,
     SymbolReference,
     TypeRef,
-    NamedTypeRef,
-    GenericInstanceTypeRef,
     UnknownTypeRef,
     Visibility,
 )

delphi_lsp/semantic.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Iterable, Optional
+from typing import Optional
 
 
 def normalize_name(name: str) -> str:

{python_delphi_lsp-2.0.4.dist-info → python_delphi_lsp-2.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 2.0.4
+Version: 2.0.5
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -41,7 +41,7 @@ Dynamic: license-file
 
 `python-delphi-lsp` parses Delphi/Object Pascal, builds semantic and project
 indexes, serves LSP, and provides bounded codebase navigation for agents.
-Version 2.0.4 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 2.0.5 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -185,15 +185,67 @@ problems; paths are not guessed.
 `delphi-lsp-agent` has these subcommands and options:
 
 ```text
+delphi-lsp-agent cache start --root PATH [--project-file FILE] [--max-memory 512M]
+                                  [--idle-timeout 1800]
+delphi-lsp-agent cache status --root PATH [--format text|json]
+delphi-lsp-agent cache stop --root PATH
 delphi-lsp-agent view --root PATH [--project-file FILE] --layer LAYER
                       [--query TEXT] [--format markdown|json] [--deep-projects]
 delphi-lsp-agent index --root PATH [--project-file FILE] [--out FILE]
+delphi-lsp-agent query --root PATH ACTION [VALUE]
+                      [--project-id FILE] [--detail summary|declaration|members|context|body|implementations]
+                      [--relation references|callers|callees|uses|used_by|inherits|implements]
+                      [--cursor TEXT] [--max-items INT] [--max-chars INT]
 delphi-lsp-agent skill install [--target PATH] [--force]
 delphi-lsp-agent opencode install [--target PATH] [--python PYTHON]
                                   [--force] [--write-agent|--write-config]
 delphi-lsp-agent worker --root PATH [--project-file FILE]
 ```
 
+The `cache` commands manage one daemon per canonical root. Use these:
+
+```bash
+delphi-lsp-agent cache start --root PATH
+delphi-lsp-agent cache status --root PATH
+delphi-lsp-agent cache stop --root PATH
+```
+
+`cache start` outputs cache lifecycle JSON; runtime warnings are still on stderr.
+`cache status --format json` outputs status JSON to stdout and the same warning stream on stderr.
+`cache stop` outputs stop status JSON and may include warnings on stderr.
+`query` outputs Protocol v2 JSON responses and writes warnings to stderr.
+
+```bash
+delphi-lsp-agent query --root PATH find TCustomer
+delphi-lsp-agent query --root PATH focus TARGET_ID
+delphi-lsp-agent query --root PATH inspect
+delphi-lsp-agent query --root PATH trace TARGET_ID --relation callers
+delphi-lsp-agent query --root PATH metrics
+delphi-lsp-agent query --root PATH metrics UNIT_QUERY
+delphi-lsp-agent cache status --root PATH --format json
+```
+
+`inspect` uses the currently focused target, so call `focus TARGET_ID` before
+`inspect` unless a previous request already selected it.
+
+The cache daemon prewarms the navigation cache at startup so first `find` requests are
+fast. The cache retained-cache budget is `512 MiB` by default and tracks retained
+cache usage only, not a hard RSS/parse peak. Warnings are emitted on stderr at or
+above 80 percent.
+
+Eviction is ordered: auxiliary caches are evicted first, navigation caches second.
+If compaction removes navigable data, the daemon rebuilds the navigation state on demand
+while preserving focus state for the next request.
+
+The daemon tracks a 30-minute idle timeout; idle state shows in JSON status (`cache status`).
+`source revision` changes on source edits and invalidate reused request caches.
+Workspace state appears in status as `requests`, `warm_hits`, `rebuilds`, `invalidations`,
+`evictions`, and `cache_state`.
+
+Metadata is stored in `.delphi-lsp/agent-cache/daemon.json` with owner-only token and
+permissions (`daemon.json` mode 600 and parent 700). Do not copy or share this token
+outside the root workspace.
+
 `view --layer` accepts `overview`, `projects`, `units`, `unit`,
 `symbols`, `symbol`, `implementation`, `references`, `problems`, and
 `metrics`. For example, `delphi-lsp-agent view --layer metrics --format json`
@@ -227,7 +279,7 @@ Focus preserves the selected project, unit, or target. Cursors bind a workspace
 revision and request fingerprint, so source changes and cross-target or
 cross-detail reuse invalidate them. `max_items` and `max_chars` bound each
 response. A `sound_partial` relation is sound but incomplete: unresolved and
-ambiguous relations are never fabricated.
+ambiguous relations are never fabricated. Unsupported relations are rejected.
 
 For every source size the navigator builds an outline first, loads source detail
 lazily for a selected target, and returns only selected fragments. Typed source
@@ -262,6 +314,11 @@ The plugin maintains one worker per session/root, reusing focus and indexes.
 During compaction it restores the focus and summary into the new context.
 Transport failure, session deletion, and plugin disposal clean up the worker.
 
+OpenCode history: 1.1.0 and 1.1.1 used a spawned view per call model.
+Persistent session/root worker support first shipped in 2.0.0.
+This is the same persistent session/root worker boundary.
+The OpenCode worker stays separate from CLI daemon, and current plugin behavior is unchanged.
+
 A generated OpenCode agent starts with this Markdown frontmatter:
 
 ```markdown

{python_delphi_lsp-2.0.4.dist-info → python_delphi_lsp-2.0.5.dist-info}/RECORD

@@ -1,20 +1,21 @@
 delphi_lsp/__init__.py,sha256=mq3tF0NrXDgbkJXDuf5HhW6sOnmP7DQxs3zl8fGoAmo,3867
-delphi_lsp/_version.py,sha256=ZOg41aCgKEuObK5WhegikXektFWPJaeZ-TMDh0Ke95M,22
-delphi_lsp/agent_cli.py,sha256=Mma4C1Ca_Hd_9dl0mePT7uIypw6j6gDWdKu9XxIMXQQ,9226
-delphi_lsp/agent_context.py,sha256=BfmsCbTIWSaMNFkPuyC31yh7wkzCzBI5xt3BE8vsIa4,77715
+delphi_lsp/_version.py,sha256=xEb7Z4b8xalXXExBg42XPAhbJKniHzcsEPjp-6S3ppg,22
+delphi_lsp/agent_cache.py,sha256=wWPdAnKtenNyjLXu8QDG5QO0GPo8MdR8cIltfaL8g3A,28700
+delphi_lsp/agent_cli.py,sha256=tr-MmWRPkevbtNKSnmcPJghTqD7zWJNPBVRvFicmb4M,15169
+delphi_lsp/agent_context.py,sha256=7f4J6oqs5hRlIqiTLy-OYZhqIJPAG73G-xm9BJq_MFw,78346
 delphi_lsp/agent_layers.py,sha256=ngFn-zH2Jv6CBjOhd3UkoyVgsrdXW0BChnQxSVmkRRc,25131
 delphi_lsp/agent_metrics.py,sha256=6y9DrSnKitZbwRFQrofanw6k89YGqbvEacqgSKHgh2c,2695
 delphi_lsp/agent_protocol.py,sha256=cZ1LIMhrkOb5CqiGcjSH1eZUNqtJCYySUc54h-PCyOs,12551
-delphi_lsp/agent_relations.py,sha256=pXhuCjfwmicG3VG7lYtGvKKv-mFPQ_hJ3w0eavqMoV0,32900
+delphi_lsp/agent_relations.py,sha256=aOeRYa6pw8VO0OyQZLk1wHE529k9DIDm3ENPM5ZOJiw,32879
 delphi_lsp/agent_templates.py,sha256=LXtbAPj0Nxvp3ycZARPELEb51BFoi2vtiCe-pYHNteE,21834
-delphi_lsp/agent_workspace.py,sha256=HvCWfMVv08Jlx257my4hkkXCLUNoPcy5AAnOnl_mNUU,23761
-delphi_lsp/binary.py,sha256=40mEpE0SBYmifwEoNHwSU7IU_D2usVyWYWHJ73aDfoo,8529
+delphi_lsp/agent_workspace.py,sha256=-WgopvaWX1Imycxnjf9Ie58sHMFhnnlh7D-nhl8tmmo,23990
+delphi_lsp/binary.py,sha256=s-c0tstGtkbjxgyiS6vteqh5D40qmVEenoECtBCsDcU,8495
 delphi_lsp/comment_builder.py,sha256=XvFW7WTbYy7yGN3MG40gtabTvhGj1ea1MYkySDbVMDA,832
 delphi_lsp/consts.py,sha256=qM40iwxXmvEileWHJVLMYlQSkLoLyQaqM-Zscz3VJbs,5958
 delphi_lsp/grammar.py,sha256=QWEMSUKr0e1xlJOveZtp7K-MvhlkvDgxkD0iUKIyxKU,18577
 delphi_lsp/lark_builder.py,sha256=c0_kFB_o3U64fwsC2BnsFibAojnqxjaZSrzASg6sTSM,119202
 delphi_lsp/lark_tokens.py,sha256=xT_GES2z6p1IdN3EnoKE9RcUM6suu1RV3J-0FEJN2r8,4176
-delphi_lsp/lsp_server.py,sha256=kxm0A-VNDkkNZKb6TSqFxur6wNcvh1m34EKIKfOr2LU,71514
+delphi_lsp/lsp_server.py,sha256=hfuv8QXGQIO2s4oWYWzOjujejXNcS_ITPQ9ikw4Ua1U,71468
 delphi_lsp/metrics.py,sha256=f70B1awypqVWZIW_SNpFHdShoS8OzDW5DWX5ftQMI0c,26166
 delphi_lsp/nodes.py,sha256=LW8KUgNCg9MHK_2NmzrgCMMJNcBwa4C76XwKoS7kt4E,13556
 delphi_lsp/parser.py,sha256=4hckHD_fsiiUe3oeSRJwqbY8bDWqJaYLsU10NYDIW6E,6025
@@ -22,14 +23,14 @@ delphi_lsp/preprocessor.py,sha256=aXJiabmCvWoUdrxYAA4EVVxDDQXl_IeFUezoDdMlFyU,30
 delphi_lsp/progress.py,sha256=FF3lqdDKLvq3b7cOhuSc3P0FDzVnX0miD8U8_3xt5iY,535
 delphi_lsp/project_discovery.py,sha256=UpezFlNJDaF5sW8tkG_HUxHpAULSf1GSWXJTlUF8vMM,20230
 delphi_lsp/project_indexer.py,sha256=J_GA1GlLrmxAajS7zHeeVHbVH7MEcf8278Yd9hcIh7o,13137
-delphi_lsp/semantic.py,sha256=egQ-_AjmnAATvL1hRUfjd4FDapFxdwi5rt8QExb0POc,9818
+delphi_lsp/semantic.py,sha256=FZ9x_QsIS_u-1DlzVlYgRqH9gQZ5ySnDAD-xHwzblU8,9808
 delphi_lsp/semantic_builder.py,sha256=ulA7xHJpltjc6cTo5wh9yTcYazuIykM-YLMXD1h-wzk,58680
 delphi_lsp/source_reader.py,sha256=HWiw25sLVZ6s1GGpMl17uZ-o68HoxTEd3Z0__m1vsSE,520
 delphi_lsp/workspace.py,sha256=TU__SujItRlW8hB2kuYC7ZJx1WQVOj7frYxvo7rDqeI,2137
 delphi_lsp/writer.py,sha256=j-cnyiHFNOTFECL7Ehm-m43ye7ev7qFeCCscFMjrAOY,2503
-python_delphi_lsp-2.0.4.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
-python_delphi_lsp-2.0.4.dist-info/METADATA,sha256=y1GTsjlMI2yUCd5Z9ZmGOHiiuRxQlf2IIQEmM5G1TyY,15390
-python_delphi_lsp-2.0.4.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_delphi_lsp-2.0.4.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
-python_delphi_lsp-2.0.4.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
-python_delphi_lsp-2.0.4.dist-info/RECORD,,
+python_delphi_lsp-2.0.5.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+python_delphi_lsp-2.0.5.dist-info/METADATA,sha256=T3eZ2AtK8UFsL-6RaVdGxWCh00c8MA06urr2pgRLYHo,18327
+python_delphi_lsp-2.0.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_delphi_lsp-2.0.5.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
+python_delphi_lsp-2.0.5.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
+python_delphi_lsp-2.0.5.dist-info/RECORD,,