patchi 0.7.5__py3-none-any.whl

patchi/core/debug/adapters/powershell.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import tempfile
+import textwrap
+from pathlib import Path
+
+_log = logging.getLogger("patchi.debug.adapters.powershell")
+
+
+class PowerShellDebugAdapter:
+    def __init__(self, script: str | Path, args: list[str] | None = None):
+        self._script = Path(script).resolve()
+        self._args = args or []
+
+    def available(self) -> bool:
+        return _find_pwsh() is not None
+
+    def capture_exception(self, timeout: float = 60) -> dict | None:
+        pwsh_path = _find_pwsh()
+        if pwsh_path is None:
+            _log.warning("pwsh not found on PATH")
+            return None
+
+        harness_code = _build_harness(self._script, self._args)
+
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".ps1", delete=False, encoding="utf-8"
+        ) as f:
+            f.write(harness_code)
+            tmp_path = Path(f.name)
+
+        try:
+            proc = subprocess.run(
+                [str(pwsh_path), "-NoProfile", "-File", str(tmp_path)],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired:
+            _log.warning("pwsh harness timed out after %s seconds", timeout)
+            return None
+        finally:
+            tmp_path.unlink(missing_ok=True)
+
+        if proc.returncode == 0:
+            return None
+
+        for line in proc.stdout.splitlines():
+            stripped = line.strip()
+            prefix = "PATCHI_DEBUG_CAPTURE:"
+            if stripped.startswith(prefix):
+                try:
+                    return json.loads(stripped[len(prefix) :])
+                except json.JSONDecodeError:
+                    _log.warning("PATCHI_DEBUG_CAPTURE JSON parse error: %.200s", stripped)
+                    return None
+
+        _log.debug(
+            "pwsh exited code=%d but no PATCHI_DEBUG_CAPTURE token in stdout",
+            proc.returncode,
+        )
+        return None
+
+    def _resolve_variables(self, var_ref: int, max_depth: int = 2, depth: int = 0) -> dict:
+        # PowerShell adapter uses harness-based debugging, not DAP protocol variables
+        msg = "PowerShell adapter uses harness-based debugging; variable resolution not available via DAP"
+        return {"__not_supported__": msg}
+
+
+def _find_pwsh() -> Path | None:
+    try:
+        result = subprocess.run(
+            ["where", "pwsh"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode == 0:
+            for line in result.stdout.splitlines():
+                p = Path(line.strip())
+                if p.is_file():
+                    return p
+    except (subprocess.SubprocessError, OSError):
+        pass
+    return None
+
+
+def _ps_quote(s: str) -> str:
+    """PowerShell single-quote a string, doubling any embedded single quotes."""
+    return "'" + s.replace("'", "''") + "'"
+
+
+def _build_harness(script: Path, args: list[str] | None) -> str:
+    script_quoted = _ps_quote(str(script))
+    # args passed as a param block at top of target script, or use splatting
+    # For simplicity, we'll set $args before dot-sourcing
+    args_setup = ""
+    if args:
+        args_vals = ", ".join(_ps_quote(a) for a in args)
+        args_setup = f"$args = @({args_vals})"
+    return textwrap.dedent(f"""\
+        $ErrorActionPreference = 'Stop'
+        {args_setup}
+
+        $__skip = @(
+            '$', '^', '?', '_', 'args', 'input', 'true', 'false', 'null',
+            'Host', 'MyInvocation', 'ExecutionContext', 'PSBoundParameters',
+            'PSVersionTable', 'PSCulture', 'PSUICulture', 'PSEdition', 'ShellId',
+            'HOME', 'PID', 'IsCoreCLR', 'IsWindows', 'IsLinux', 'IsMacOS',
+            'PSCommandPath', 'PSScriptRoot', 'PSHOME', 'PSModulePath',
+            'EnabledExperimentalFeatures', 'Error', 'ErrorActionPreference',
+            'ProgressPreference', 'VerbosePreference', 'DebugPreference',
+            'WarningPreference', 'InformationPreference', 'ConfirmPreference',
+            'WhatIfPreference', 'NestedPromptLevel', 'FormatEnumerationLimit',
+            'MaximumHistoryCount', 'OutputEncoding', 'PSDefaultParameterValues',
+            'PSEmailServer', 'PSNativeCommandArgumentPassing',
+            'PSNativeCommandUseErrorActionPreference', 'PSSessionApplicationName',
+            'PSSessionConfigurationName', 'PSSessionOption', 'PSStyle', 'PWD',
+            'PROFILE', 'StackTrace', 'PSItem'
+        )
+
+        try {{
+            . {script_quoted}
+        }} catch {{
+            $__err = $_
+            $__capture = @{{
+                exception = "$($__err.Exception.GetType().Name): $($__err.Exception.Message)"
+                thread_id = 1
+                frames = @()
+            }}
+
+            # Parse ScriptStackTrace for frames
+            $__stackText = $__err.ScriptStackTrace
+            if ($__stackText) {{
+                $__lines = $__stackText -split "`r?`n" | Where-Object {{ $_ -match '^at\\s' }}
+                foreach ($__line in $__lines) {{
+                    # Format: "at <Function>, <Path>: line <Number>"
+                    if ($__line -match '^at\\s+(.+?),\\s+(.+?):\\s*line\\s+(\\d+)') {{
+                        $__func = $matches[1].Trim()
+                        $__path = $matches[2].Trim()
+                        $__lineNum = [int]$matches[3]
+                        $__capture.frames += @{{
+                            name = $__func
+                            path = $__path
+                            line = $__lineNum
+                            locals = @{{}}
+                        }}
+                    }}
+                }}
+            }}
+
+            # Add InvocationInfo frame if not already in stack
+            $__inv = $__err.InvocationInfo
+            if ($__inv -and $__inv.ScriptName) {{
+                $__found = $false
+                foreach ($__f in $__capture.frames) {{
+                    if ($__f.path -eq $__inv.ScriptName -and $__f.line -eq $__inv.ScriptLineNumber) {{
+                        $__found = $true
+                        break
+                    }}
+                }}
+                if (-not $__found) {{
+                    $__capture.frames += @{{
+                        name = if ($__inv.CommandName) {{ $__inv.CommandName }} else {{ '<ScriptBlock>' }}
+                        path = $__inv.ScriptName
+                        line = $__inv.ScriptLineNumber
+                        locals = @{{}}
+                    }}
+                }}
+            }}
+
+# Capture script-level variables from scope 0 (catch scope = script scope due to dot-source)
+        $__locals = @{{}}
+        $__vars = Get-Variable -Scope 0 -ErrorAction SilentlyContinue
+        foreach ($__v in $__vars) {{
+            $__n = $__v.Name
+            # Skip internal harness vars (__*), automatic vars, preference vars, and regex match vars
+            if ($__n -notlike '__*' -and $__n -notlike '*Preference' -and $__n -notin $__skip -and $__n -notin @('foreach','switch','Error','ErrorView','MyInvocation','PSBoundParameters','PSVersionTable','PSCulture','PSUICulture','PSEdition','ShellId','HOME','PID','IsCoreCLR','IsWindows','IsLinux','IsMacOS','PSCommandPath','PSScriptRoot','PSHOME','PSModulePath','EnabledExperimentalFeatures','ErrorActionPreference','ProgressPreference','VerbosePreference','DebugPreference','WarningPreference','InformationPreference','ConfirmPreference','WhatIfPreference','NestedPromptLevel','FormatEnumerationLimit','MaximumHistoryCount','OutputEncoding','PSDefaultParameterValues','PSEmailServer','PSNativeCommandArgumentPassing','PSNativeCommandUseErrorActionPreference','PSSessionApplicationName','PSSessionConfigurationName','PSSessionOption','PSStyle','PWD','PROFILE','StackTrace','PSItem','?','_','args','input','true','false','null','$','^','Host','ExecutionContext','matches')) {{
+                try {{
+                    if ($null -ne $__v.Value) {{
+                        $__val = "$($__v.Value)"
+                        if ($__val.Length -gt 200) {{ $__val = $__val.Substring(0,200) + '...' }}
+                    }} else {{
+                        $__val = '$null'
+                    }}
+                }} catch {{
+                    $__val = '{{?}}'
+                }}
+                $__locals[$__n] = $__val
+            }}
+        }}
+            # Assign captured locals to the SCRIPT frame (index 1 = script level), not function frame
+            if ($__capture.frames.Count -gt 1) {{
+                $__capture.frames[1].locals = $__locals
+            }} elseif ($__capture.frames.Count -gt 0) {{
+                $__capture.frames[0].locals = $__locals
+            }}
+
+            try {{
+                $__json = $__capture | ConvertTo-Json -Depth 10 -Compress
+                Write-Output "PATCHI_DEBUG_CAPTURE:$__json"
+            }} catch {{
+                Write-Output "PATCHI_DEBUG_CAPTURE:SERIALIZE_FAILED"
+            }}
+            exit 1
+        }}
+        """)

patchi/core/debug/adapters/python.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+_LOG = logging.getLogger("patchi.debug.adapters.python")
+
+
+class PythonDebugAdapter:
+    def __init__(self, script: str | Path, args: list[str] | None = None):
+        self._script = Path(script).resolve()
+        self._args = args or []
+
+    def capture_exception(self, timeout: float = 60) -> dict | None:
+        # 1) Standalone exec harness — catches module-level crashes in plain
+        #    scripts (the fast, dependency-free path).
+        cap = self._capture_standalone(timeout)
+        if cap is not None:
+            return cap
+
+        # 2) Pytest harness — a real test file imports cleanly but only fails
+        #    *inside* a test function, which the standalone harness can't see.
+        if _looks_like_test_file(self._script):
+            cap = self._capture_pytest(timeout)
+            if cap is not None:
+                return cap
+
+        return None
+
+    def _capture_standalone(self, timeout: float) -> dict | None:
+        harness = _build_harness(self._script)
+        cmd = [sys.executable, "-Xfrozen_modules=off", "-c", harness, *self._args]
+        _LOG.debug("running python harness: %s …", " ".join(cmd[:4]))
+
+        try:
+            proc = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired:
+            _LOG.warning("python harness timed out after %s seconds", timeout)
+            return None
+        except OSError as e:
+            _LOG.warning("python harness failed to start: %s", e)
+            return None
+        if proc.returncode == 0:
+            return None
+
+        for stream in (proc.stdout, proc.stderr):
+            for line in stream.splitlines():
+                stripped = line.strip()
+                prefix = "PATCHI_DEBUG_CAPTURE:"
+                if stripped.startswith(prefix):
+                    try:
+                        return json.loads(stripped[len(prefix) :])
+                    except json.JSONDecodeError:
+                        _LOG.warning("PATCHI_DEBUG_CAPTURE JSON parse error: %.200s", stripped)
+                        return None
+
+        _LOG.debug("python exited code=%d but no capture token", proc.returncode)
+        return None
+
+    def _capture_pytest(self, timeout: float) -> dict | None:
+        harness = _build_pytest_harness(self._script)
+        cmd = [sys.executable, "-Xfrozen_modules=off", "-c", harness, *self._args]
+        _LOG.debug("running pytest harness: %s …", " ".join(cmd[:4]))
+
+        try:
+            proc = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired:
+            _LOG.warning("pytest harness timed out after %s seconds", timeout)
+            return None
+
+        for stream in (proc.stderr, proc.stdout):
+            for line in stream.splitlines():
+                stripped = line.strip()
+                prefix = "PATCHI_DEBUG_CAPTURE:"
+                if stripped.startswith(prefix):
+                    try:
+                        return json.loads(stripped[len(prefix) :])
+                    except json.JSONDecodeError:
+                        _LOG.warning("PATCHI_DEBUG_CAPTURE JSON parse error: %.200s", stripped)
+                        return None
+
+        _LOG.debug("pytest exited code=%d but no capture token", proc.returncode)
+        return None
+
+    def _resolve_variables(self, var_ref: int, max_depth: int = 2, depth: int = 0) -> dict:
+        # Python adapter uses harness-based debugging, not DAP protocol variables
+        msg = "Python adapter uses harness-based debugging; variable resolution not available via DAP"
+        return {"__not_supported__": msg}
+
+
+def _looks_like_test_file(script: Path) -> bool:
+    """Heuristic: does the file look like a pytest/unittest test module?"""
+    try:
+        text = script.read_text(encoding="utf-8-sig", errors="replace")
+    except OSError:
+        return False
+    if "pytest" in text or "unittest" in text:
+        return True
+    if "def test_" in text or "class Test" in text:
+        return True
+    return False
+
+
+def _build_harness(script: Path) -> str:
+    """Generate a Python script that wraps the target in an exception hook
+    that captures local variables and prints them as JSON on stdout.
+
+    ``__file__`` and ``__name__`` are injected so scripts that read them at
+    module level don't blow up (``python -c`` otherwise has no ``__file__``).
+    """
+    script_code = script.read_text(encoding="utf-8-sig", errors="replace")
+    return textwrap.dedent(f"""\
+        import json, sys
+
+        def _patchi_capture(exc_type, exc_value, exc_tb):
+            frames = []
+            tb = exc_tb
+            while tb:
+                frame = tb.tb_frame
+                fname = frame.f_code.co_name
+                fpath = frame.f_code.co_filename
+                lineno = tb.tb_lineno
+                # Only include user frames, not the harness itself
+                if '<string>' not in fpath:
+                    # Capture locals for every user frame, redacting secrets
+                    # so credentials never reach the AI prompt.
+                    locals_ = {{k: _patchi_redact(k, v) for k, v in frame.f_locals.items()
+                                if not k.startswith('_')}}
+                    frames.append({{
+                        "name": fname,
+                        "path": fpath,
+                        "line": lineno,
+                        "locals": locals_,
+                    }})
+                tb = tb.tb_next
+            frames.reverse()
+            data = {{
+                "exception": f"{{exc_type.__name__}}: {{exc_value}}",
+                "thread_id": 1,
+                "frames": frames,
+            }}
+            # stderr + token prefix: the target script may print to stdout
+            # before crashing, so a bare JSON dump would be polluted.
+            print("PATCHI_DEBUG_CAPTURE:" + json.dumps(data), file=sys.stderr, flush=True)
+
+        import re as _re
+        _SECRET_NAMES = _re.compile(
+            r"(password|passwd|secret|token|api[_-]?key|apikey|credential|authorization|private[_-]?key|access[_-]?key|session[_-]?id|aws[_-]?secret)", _re.I)
+
+        def _patchi_redact(k, v):
+            if _SECRET_NAMES.search(k):
+                return "{{REDACTED}}"
+            return repr(v)
+
+        sys.excepthook = _patchi_capture
+
+        _globals = {{'__name__': '__main__', '__file__': {str(script)!r}, '__builtins__': __builtins__}}
+        exec(compile({script_code!r}, {str(script)!r}, "exec"), _globals)
+        """)
+
+
+def _build_pytest_harness(script: Path) -> str:
+    """Generate a harness that runs the target file under pytest and captures
+    the first test failure's traceback + locals via a small in-process plugin.
+
+    The plugin serializes the capture and prints a single line prefixed with
+    ``PATCHI_DEBUG_CAPTURE:`` so the adapter can parse it reliably.
+    """
+    return textwrap.dedent(f"""\
+        import json, sys
+        import pytest
+
+        _captured = {{}}
+
+        def _patchi_capture_frames(exc_tb):
+            import re as _re
+            import sys as _sys
+            _SECRET_NAMES = _re.compile(
+                r"(password|passwd|secret|token|api[_-]?key|apikey|credential|authorization|private[_-]?key|access[_-]?key|session[_-]?id|aws[_-]?secret)", _re.I)
+
+            def _redact(k, v):
+                if _SECRET_NAMES.search(k):
+                    return "{{REDACTED}}"
+                return repr(v)
+
+            frames = []
+            tb = exc_tb
+            while tb:
+                frame = tb.tb_frame
+                fname = frame.f_code.co_name
+                fpath = frame.f_code.co_filename
+                lineno = tb.tb_lineno
+                # Keep user frames only: skip the harness and Python internals.
+                norm = fpath.replace("\\\\", "/")
+                is_stdlib = norm.startswith(_sys.prefix.replace("\\\\", "/") + "/")
+                if "<string>" not in fpath and "site-packages" not in norm and not is_stdlib:
+                    locals_ = {{k: _redact(k, v) for k, v in frame.f_locals.items()
+                                if not k.startswith('_')}}
+                    frames.append({{
+                        "name": fname,
+                        "path": fpath,
+                        "line": lineno,
+                        "locals": locals_,
+                    }})
+                tb = tb.tb_next
+            frames.reverse()
+            return frames
+
+        class _CapturePlugin:
+            def pytest_runtest_makereport(self, item, call):
+                global _captured
+                if _captured:
+                    return
+                if call.when == "call" and call.excinfo is not None:
+                    exc = call.excinfo
+                    _captured = {{
+                        "exception": f"{{exc.type.__name__}}: {{exc.value}}",
+                        "thread_id": 1,
+                        "frames": _patchi_capture_frames(exc.tb),
+                    }}
+
+            def pytest_sessionfinish(self, session, exitstatus):
+                if _captured:
+                    # stderr: pytest writes its own progress chars to stdout,
+                    # so a token on stdout would be prefixed with them.
+                    print("PATCHI_DEBUG_CAPTURE:" + json.dumps(_captured), file=sys.stderr, flush=True)
+
+        sys.exit(pytest.main([{str(script)!r}, "-x", "-q", "-s", "--no-header", "--tb=short"],
+                             plugins=[_CapturePlugin()]))
+        """)

patchi/core/debug/capture.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from patchi.core.debug.adapters.codelldb import CodeLLDBAdapter
+from patchi.core.debug.adapters.node import NodeDebugAdapter
+from patchi.core.debug.adapters.powershell import PowerShellDebugAdapter
+from patchi.core.debug.adapters.python import PythonDebugAdapter
+
+_log = logging.getLogger("patchi.core.debug.capture")
+
+# File types the harnesses can actually run. Anything else is refused so a
+# finding pointing at, say, a log file can never be executed as code.
+_CAPTURE_EXTENSIONS = frozenset({".py", ".js", ".ts", ".ps1"})
+
+
+class DebugCapture:
+    """Structured capture of runtime state at the moment of an exception.
+
+    Designed for AI fix-agent consumption — compact, information-dense,
+    variable-oriented.  Every method returns plain dicts / lists so the
+    caller can serialize or format however it likes.
+    """
+
+    def __init__(self, raw: dict) -> None:
+        self._raw = raw
+
+    @property
+    def exception(self) -> str:
+        return self._raw.get("exception", "")
+
+    @property
+    def thread_id(self) -> int:
+        return self._raw.get("thread_id", 0)
+
+    @property
+    def frames(self) -> list[dict]:
+        return self._raw.get("frames", [])
+
+    @property
+    def trigger_frame(self) -> int:
+        """Index of the deepest non-library frame (the 'real' crash site)."""
+        for i, f in enumerate(self.frames):
+            if f.get("path") and "site-packages" not in f["path"].replace("\\", "/"):
+                return i
+        return 0
+
+    def variable_summary(self, max_var_len: int = 80) -> str:
+        """Human- and AI-readable one-line-per-frame summary.
+
+        Example output::
+
+            #1  process_order  myapp/orders.py:42
+                total -> None  (expected int)
+                user -> User(id=123, name='Alice')
+                items -> [<list: 3 items>]
+        """
+        lines: list[str] = []
+        for i, f in enumerate(self.frames):
+            marker = " <-- trigger" if i == self.trigger_frame else ""
+            lines.append(
+                f"#{i}  {f['name']}  {_short_path(f.get('path', ''))}:{f.get('line', 0)}{marker}"
+            )
+            for k, v in f.get("locals", {}).items():
+                val = _short_value(v, max_var_len)
+                lines.append(f"    {k} -> {val}")
+        return "\n".join(lines)
+
+    def to_dict(self, max_vars: int = 15) -> dict:
+        """Compact dict ready for JSON serialisation.
+
+        ``max_vars`` limits the total number of variable entries across all
+        frames to keep the payload small for LLM context windows.
+        """
+        capped = []
+        remaining = max_vars
+        for f in self.frames:
+            frame: dict = {
+                "name": f["name"],
+                "path": _short_path(f.get("path", "")),
+                "line": f.get("line", 0),
+            }
+            if remaining > 0:
+                locals_capped = {}
+                for k, v in list(f.get("locals", {}).items())[:remaining]:
+                    locals_capped[k] = _short_value(v, 60)
+                frame["locals"] = locals_capped
+                remaining -= len(locals_capped)
+            capped.append(frame)
+        return {
+            "exception": self.exception,
+            "trigger_frame": self.trigger_frame,
+            "frames": capped,
+        }
+
+
+def capture_exception(
+    script: str | Path,
+    args: list[str] | None = None,
+    timeout: float = 60,
+) -> DebugCapture | None:
+    """Convenience: run *script* under the debugger and return a
+    :class:`DebugCapture` or *None* if it exited cleanly.
+
+    This is the primary entry point for Patchi fix agents.
+    """
+    ext = Path(script).suffix.lower()
+
+    if ext == ".py":
+        adapter = PythonDebugAdapter(script, args)
+    elif ext == ".ps1":
+        adapter = PowerShellDebugAdapter(script, args)
+    elif ext in (".js", ".ts"):
+        adapter = NodeDebugAdapter(script, args)
+    else:
+        _log.warning("unsupported file extension %s – defaulting to Python harness", ext)
+        adapter = PythonDebugAdapter(script, args)
+
+    raw = adapter.capture_exception(timeout=timeout)
+    if raw is None:
+        return None
+    return DebugCapture(raw)
+
+
+def capture_rust_crash(
+    binary: str | Path,
+    args: list[str] | None = None,
+    timeout: float = 60,
+) -> DebugCapture | None:
+    """Run a compiled Rust (or C++) binary under CodeLLDB and return a
+    :class:`DebugCapture` if it crashes, or *None* if it exits cleanly.
+
+    If codelldb is not installed, returns *None* gracefully.
+    """
+    adapter = CodeLLDBAdapter(binary, args)
+    raw = adapter.capture_crash(timeout=timeout)
+    if raw is None:
+        return None
+    return DebugCapture(raw)
+
+
+def capture_powershell_crash(
+    script: str | Path,
+    args: list[str] | None = None,
+    timeout: float = 60,
+) -> DebugCapture | None:
+    """Run a PowerShell script under the debug harness and return a
+    :class:`DebugCapture` if it crashes, or *None* if it exits cleanly.
+
+    If pwsh is not installed, returns *None* gracefully.
+    """
+    adapter = PowerShellDebugAdapter(script, args)
+    raw = adapter.capture_exception(timeout=timeout)
+    if raw is None:
+        return None
+    return DebugCapture(raw)
+
+
+def debug_context_from_finding(finding: dict, root: Path) -> dict | None:
+    """Return a debug-context dict if *finding* is a test failure, else *None*.
+
+    Runs the failing test file under the debugger harness and returns compact
+    runtime-state data for the AI prompt.
+    """
+    if finding.get("type") != "test_failure":
+        return None
+    test_file = finding.get("file", "")
+    if not test_file:
+        return None
+    # The finding path comes from the scanned repo — never let it escape the
+    # project root: an absolute path or "../" traversal would make us execute
+    # an arbitrary file outside the project as code.
+    root_resolved = Path(root).resolve()
+    test_path = (root_resolved / test_file).resolve()
+    try:
+        test_path.relative_to(root_resolved)
+    except ValueError:
+        _log.warning("refusing to capture outside project root: %s", test_file)
+        return None
+    if not test_path.is_file():
+        return None
+    if test_path.suffix.lower() not in _CAPTURE_EXTENSIONS:
+        _log.warning("refusing to capture unsupported file type: %s", test_file)
+        return None
+
+    cap = capture_exception(test_path, timeout=30)
+    if cap is None:
+        return None
+    return cap.to_dict(max_vars=15)
+
+
+def _short_path(p: str) -> str:
+    try:
+        return str(Path(p).relative_to(Path.cwd()))
+    except ValueError:
+        return p
+
+
+def _short_value(val, max_len: int) -> str:
+    if isinstance(val, dict):
+        if val.get("__depth_limit__"):
+            return "{...}"
+        if val.get("__error__"):
+            return "{?}"
+        return f"{{{', '.join(_short_value(v, 20) for v in list(val.values())[:3])}{'…' if len(val) > 3 else ''}}}"
+    s = str(val)
+    if len(s) > max_len:
+        return s[: max_len - 3] + "..."
+    return s