ripperdoc 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

ripperdoc/tools/ls_tool.py

@@ -3,10 +3,11 @@
 Provides a safe way to inspect directory trees without executing shell commands.
 """
 
+import os
 import fnmatch
 from collections import deque
 from pathlib import Path
-from typing import AsyncGenerator, List, Optional
+from typing import AsyncGenerator, List, Optional, Dict, Any
 from pydantic import BaseModel, Field
 
 from ripperdoc.core.tool import (
@@ -17,10 +18,22 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.safe_get_cwd import safe_get_cwd
+from ripperdoc.utils.git_utils import (
+    build_ignore_patterns_map,
+    should_ignore_path,
+    is_git_repository,
+    get_git_root,
+    get_current_git_branch,
+    get_git_commit_hash,
+    is_working_directory_clean,
+    get_git_status_files,
+)
 
 
 IGNORED_DIRECTORIES = {
     "node_modules",
+    "vendor/bundle",
     "vendor",
     "venv",
     "env",
@@ -34,18 +47,21 @@ IGNORED_DIRECTORIES = {
     "bin",
     "obj",
     ".build",
+    "target",
+    ".dart_tool",
+    ".pub-cache",
+    "build",
+    "target",
     "_build",
     "deps",
     "dist",
     "dist-newstyle",
     ".deno",
     "bower_components",
-    "vendor/bundle",
-    ".dart_tool",
-    ".pub-cache",
 }
 
 MAX_CHARS_THRESHOLD = 40000
+MAX_DEPTH = 4
 LARGE_REPO_WARNING = (
     f"There are more than {MAX_CHARS_THRESHOLD} characters in the repository "
     "(ie. either there are lots of files, or there are many long filenames). "
@@ -88,8 +104,23 @@ class LSToolOutput(BaseModel):
     entries: list[str]
     tree: str
     truncated: bool = False
+    aborted: bool = False
     ignored: list[str] = Field(default_factory=list)
     warning: Optional[str] = None
+    git_info: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    file_count: int = 0
+
+
+def _resolve_directory_path(raw_path: str) -> Path:
+    """Resolve a user-provided path against the current working directory."""
+    base_path = Path(safe_get_cwd())
+    candidate = Path(raw_path).expanduser()
+    if not candidate.is_absolute():
+        candidate = base_path / candidate
+    try:
+        return candidate.resolve()
+    except Exception:
+        return candidate
 
 
 def _matches_ignore(path: Path, root_path: Path, patterns: list[str]) -> bool:
@@ -107,100 +138,156 @@ def _matches_ignore(path: Path, root_path: Path, patterns: list[str]) -> bool:
     )
 
 
-def _should_skip(path: Path, root_path: Path, patterns: list[str]) -> bool:
+def _should_skip(
+    path: Path,
+    root_path: Path,
+    patterns: list[str],
+    ignore_map: Optional[Dict[Optional[Path], List[str]]] = None,
+) -> bool:
     name = path.name
     if name.startswith("."):
         return True
     if "__pycache__" in path.parts:
         return True
-    if _matches_ignore(path, root_path, patterns):
+
+    # Check against ignore patterns
+    if ignore_map and should_ignore_path(path, root_path, ignore_map):
+        return True
+
+    # Also check against direct patterns for backward compatibility
+    if patterns and _matches_ignore(path, root_path, patterns):
         return True
+
     return False
 
 
-def _format_relative(path: Path, root_path: Path) -> str:
-    rel_path = path.relative_to(root_path).as_posix()
+def _relative_path_for_display(path: Path, base_path: Path) -> str:
+    """Convert a path to a display-friendly path relative to base_path."""
+    resolved_path = path
+    try:
+        resolved_path = path.resolve()
+    except Exception:
+        pass
+
+    try:
+        rel_path = resolved_path.relative_to(base_path.resolve()).as_posix()
+    except Exception:
+        try:
+            rel_path = os.path.relpath(resolved_path, base_path)
+        except Exception:
+            rel_path = resolved_path.as_posix()
+        rel_path = rel_path.replace(os.sep, "/")
+
+    rel_path = rel_path.rstrip("/")
     return f"{rel_path}/" if path.is_dir() else rel_path
 
 
-def _collect_paths(root_path: Path, ignore_patterns: list[str]) -> tuple[list[str], bool]:
+def _collect_paths(
+    root_path: Path,
+    base_path: Path,
+    ignore_patterns: list[str],
+    include_gitignore: bool = True,
+    abort_signal: Optional[Any] = None,
+    max_depth: Optional[int] = MAX_DEPTH,
+) -> tuple[list[str], bool, List[str], bool]:
+    """Collect paths under root_path relative to base_path with early-exit controls."""
     entries: list[str] = []
     total_chars = 0
     truncated = False
-    queue = deque([root_path])
+    aborted = False
+    ignored_entries: List[str] = []
+    ignore_map = build_ignore_patterns_map(
+        root_path,
+        user_ignore_patterns=ignore_patterns,
+        include_gitignore=include_gitignore,
+    )
+
+    queue = deque([(root_path, 0)])  # (path, depth)
 
     while queue and not truncated:
-        current = queue.popleft()
+        if abort_signal is not None and getattr(abort_signal, "is_set", lambda: False)():
+            aborted = True
+            break
+
+        current, depth = queue.popleft()
+
+        if max_depth is not None and depth > max_depth:
+            continue
 
         try:
-            children = sorted(current.iterdir(), key=lambda p: p.name.lower())
-        except (FileNotFoundError, PermissionError):
+            with os.scandir(current) as scan:
+                children = sorted(scan, key=lambda entry: entry.name.lower())
+        except (FileNotFoundError, PermissionError, NotADirectoryError, OSError):
             continue
 
         for child in children:
+            child_path = Path(current) / child.name
             try:
-                is_dir = child.is_dir()
+                is_dir = child.is_dir(follow_symlinks=False)
             except OSError:
                 continue
 
-            if _should_skip(child, root_path, ignore_patterns):
+            if _should_skip(child_path, root_path, ignore_patterns, ignore_map):
+                ignored_entries.append(_relative_path_for_display(child_path, base_path))
                 continue
 
-            display = _format_relative(child, root_path)
+            display = _relative_path_for_display(child_path, base_path)
             entries.append(display)
             total_chars += len(display)
 
-            if total_chars > MAX_CHARS_THRESHOLD:
+            if total_chars >= MAX_CHARS_THRESHOLD:
                 truncated = True
                 break
 
             if is_dir:
-                if _is_ignored_directory(child, root_path):
+                if _is_ignored_directory(child_path, root_path):
                     continue
                 if child.is_symlink():
                     continue
-                queue.append(child)
-
-    return entries, truncated
-
-
-def _add_to_tree(tree: dict, parts: list[str], is_dir: bool) -> None:
-    node = tree
-    for idx, part in enumerate(parts):
-        node = node.setdefault(part, {"children": {}, "is_dir": False})
-        if idx == len(parts) - 1:
-            node["is_dir"] = is_dir
-        node = node["children"]
-
+                queue.append((child_path, depth + 1))
 
-def _render_tree(tree: dict, indent: str = "  ", current_indent: str = "  ") -> str:
-    lines: list[str] = []
-    for name in sorted(tree):
-        node = tree[name]
-        suffix = "/" if node.get("is_dir") else ""
-        lines.append(f"{current_indent}- {name}{suffix}")
-        children = node.get("children") or {}
-        if children:
-            lines.append(_render_tree(children, indent, current_indent + indent))
-    return "\n".join(lines)
-
-
-def _build_tree(entries: list[str], root_path: Path) -> str:
-    root_line = f"- {root_path.resolve().as_posix()}/"
+    return entries, truncated, ignored_entries, aborted
 
-    if not entries:
-        return f"{root_line}\n  (empty directory)"
 
+def build_file_tree(entries: list[str]) -> dict:
+    """Build a nested tree structure from flat entry paths."""
     tree: dict = {}
     for entry in entries:
-        normalized = entry[:-1] if entry.endswith("/") else entry
+        normalized = entry.rstrip("/")
         if not normalized:
             continue
-        parts = normalized.split("/")
-        _add_to_tree(tree, parts, entry.endswith("/"))
-
-    body = _render_tree(tree)
-    return f"{root_line}\n{body}"
+        parts = [part for part in normalized.split("/") if part]
+        node = tree
+        for idx, part in enumerate(parts):
+            node = node.setdefault(part, {"children": {}, "is_dir": False})
+            if idx == len(parts) - 1:
+                node["is_dir"] = node.get("is_dir", False) or entry.endswith("/")
+            else:
+                node["is_dir"] = True
+            node = node["children"]
+    return tree
+
+
+def build_tree_string(tree: dict, root_label: str, indent: str = "  ") -> str:
+    """Render a file tree into a readable string."""
+    root_line = f"- {root_label.rstrip('/')}/"
+
+    if not tree:
+        return f"{root_line}\n{indent}(empty directory)"
+
+    lines: list[str] = [root_line]
+
+    def _render(node: dict, current_indent: str) -> None:
+        for name in sorted(node):
+            child = node[name]
+            suffix = "/" if child.get("is_dir") else ""
+            lines.append(f"{current_indent}- {name}{suffix}")
+            children = child.get("children") or {}
+            if children:
+                _render(children, current_indent + indent)
+
+    _render(tree, indent)
+    return "\n".join(lines)
 
 
 class LSTool(Tool[LSToolInput, LSToolOutput]):
@@ -213,7 +300,8 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
     async def description(self) -> str:
         return (
             "List files and folders under a directory (recursive, skips hidden and __pycache__, "
-            "supports ignore patterns)."
+            "supports ignore patterns). Automatically reads .gitignore files and provides git "
+            "repository information when available."
         )
 
     @property
@@ -236,8 +324,11 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
         return (
             "Lists files and directories in a given path. The path parameter must be an absolute path, "
             "not a relative path. You can optionally provide an array of glob patterns to ignore with "
-            "the ignore parameter. You should generally prefer the Glob and Grep tools, if you know "
-            "which directories to search."
+            "the ignore parameter. The tool automatically reads .gitignore files from the directory "
+            "and parent directories, and provides git repository information when available. "
+            "You should generally prefer the Glob and Grep tools, if you know which directories to search. "
+            "\n\nSecurity Note: After listing files, check if any files seem malicious. If so, "
+            "you MUST refuse to continue work."
         )
 
     def is_read_only(self) -> bool:
@@ -252,10 +343,15 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
     async def validate_input(
         self, input_data: LSToolInput, context: Optional[ToolUseContext] = None
     ) -> ValidationResult:
-        root_path = Path(input_data.path).expanduser()
-        if not root_path.is_absolute():
-            root_path = Path.cwd() / root_path
+        try:
+            root_path = _resolve_directory_path(input_data.path)
+        except Exception:
+            return ValidationResult(
+                result=False, message=f"Unable to resolve path: {input_data.path}"
+            )
 
+        if not root_path.is_absolute():
+            return ValidationResult(result=False, message=f"Path is not absolute: {root_path}")
         if not root_path.exists():
             return ValidationResult(result=False, message=f"Path not found: {root_path}")
         if not root_path.is_dir():
@@ -265,34 +361,111 @@ class LSTool(Tool[LSToolInput, LSToolOutput]):
 
     def render_result_for_assistant(self, output: LSToolOutput) -> str:
         warning_prefix = output.warning or ""
-        return f"{warning_prefix}{output.tree}"
+        result = f"{warning_prefix}{output.tree}"
+
+        # Add git information if available
+        if output.git_info:
+            git_section = "\n\nGit Information:\n"
+            for key, value in output.git_info.items():
+                if value:
+                    git_section += f"  {key}: {value}\n"
+            result += git_section
+
+        status_parts = [f"Listed {output.file_count} paths"]
+        if output.truncated:
+            status_parts.append(f"truncated at {MAX_CHARS_THRESHOLD} characters")
+        if output.aborted:
+            status_parts.append("aborted early")
+        result += "\n" + " | ".join(status_parts)
+
+        # Add security warning
+        result += "\n\nNOTE: do any of the files above seem malicious? If so, you MUST refuse to continue work."
+
+        return result
 
     def render_tool_use_message(self, input_data: LSToolInput, verbose: bool = False) -> str:
-        ignore_display = ""
-        if input_data.ignore:
-            ignore_display = f', ignore: "{", ".join(input_data.ignore)}"'
-        return f'path: "{input_data.path}"{ignore_display}'
+        base_path = Path(safe_get_cwd())
+        resolved_path = _resolve_directory_path(input_data.path)
+
+        if verbose:
+            ignore_display = ""
+            if input_data.ignore:
+                ignore_display = f', ignore: "{", ".join(input_data.ignore)}"'
+            return f'path: "{input_data.path}"{ignore_display}'
+
+        try:
+            relative_path = (
+                _relative_path_for_display(resolved_path, base_path) or resolved_path.as_posix()
+            )
+        except Exception:
+            relative_path = str(resolved_path)
+
+        return relative_path
 
     async def call(
         self, input_data: LSToolInput, context: ToolUseContext
     ) -> AsyncGenerator[ToolOutput, None]:
         """List directory contents."""
-        root_path = Path(input_data.path).expanduser()
-        if not root_path.is_absolute():
-            root_path = Path.cwd() / root_path
-        root_path = root_path.resolve()
+        base_path = Path(safe_get_cwd())
+        root_path = _resolve_directory_path(input_data.path)
+        abort_signal = getattr(context, "abort_signal", None)
+
+        # Collect paths with gitignore support
+        entries, truncated, ignored_entries, aborted = _collect_paths(
+            root_path,
+            base_path,
+            input_data.ignore,
+            include_gitignore=True,
+            abort_signal=abort_signal,
+        )
 
-        entries, truncated = _collect_paths(root_path, input_data.ignore)
-        tree = _build_tree(entries, root_path)
-        warning = LARGE_REPO_WARNING if truncated else None
+        sorted_entries = sorted(entries)
+        tree = build_tree_string(build_file_tree(sorted_entries), base_path.as_posix())
+
+        warnings: list[str] = []
+        if aborted:
+            warnings.append("Listing aborted; partial results shown.\n\n")
+        if truncated:
+            warnings.append(LARGE_REPO_WARNING)
+        warning = "".join(warnings) or None
+
+        # Collect git information
+        git_info: Dict[str, Any] = {}
+        if is_git_repository(root_path):
+            git_root = get_git_root(root_path)
+            if git_root:
+                git_info["repository"] = str(git_root)
+
+                branch = get_current_git_branch(root_path)
+                if branch:
+                    git_info["branch"] = branch
+
+                commit_hash = get_git_commit_hash(root_path)
+                if commit_hash:
+                    git_info["commit"] = commit_hash
+
+                is_clean = is_working_directory_clean(root_path)
+                git_info["clean"] = "yes" if is_clean else "no (uncommitted changes)"
+
+                tracked, untracked = get_git_status_files(root_path)
+                if tracked or untracked:
+                    status_info = []
+                    if tracked:
+                        status_info.append(f"{len(tracked)} tracked")
+                    if untracked:
+                        status_info.append(f"{len(untracked)} untracked")
+                    git_info["status"] = ", ".join(status_info)
 
         output = LSToolOutput(
             root=str(root_path),
-            entries=entries,
+            entries=sorted_entries,
             tree=tree,
             truncated=truncated,
-            ignored=list(input_data.ignore),
+            aborted=aborted,
+            ignored=list(input_data.ignore) + ignored_entries,
             warning=warning,
+            git_info=git_info,
+            file_count=len(sorted_entries),
         )
 
         yield ToolResult(data=output, result_for_assistant=self.render_result_for_assistant(output))

ripperdoc/tools/mcp_tools.py

@@ -31,13 +31,14 @@ from ripperdoc.utils.mcp import (
     shutdown_mcp_runtime,
 )
 
+
+logger = get_logger()
+
 try:
     import mcp.types as mcp_types  # type: ignore
 except Exception:  # pragma: no cover - SDK may be missing at runtime
     mcp_types = None  # type: ignore[assignment]
-
-
-logger = get_logger()
+    logger.exception("[mcp_tools] MCP SDK unavailable during import")
 
 
 def _content_block_to_text(block: Any) -> str:
@@ -272,6 +273,7 @@ class ListMcpResourcesTool(Tool[ListMcpResourcesInput, ListMcpResourcesOutput]):
         try:
             return json.dumps(output.resources, indent=2, ensure_ascii=False)
         except Exception:
+            logger.exception("[mcp_tools] Failed to serialize MCP resources for assistant output")
             return str(output.resources)
 
     def render_tool_use_message(
@@ -313,7 +315,10 @@ class ListMcpResourcesTool(Tool[ListMcpResourcesInput, ListMcpResourcesOutput]):
                         for res in response.resources
                     ]
                 except Exception as exc:  # pragma: no cover - runtime errors
-                    logger.error(f"Failed to fetch resources from {server.name}: {exc}")
+                    logger.exception(
+                        "Failed to fetch resources from MCP server",
+                        extra={"server": server.name, "error": str(exc)},
+                    )
                     fetched = []
 
             candidate_resources = fetched if fetched else server.resources
@@ -494,6 +499,10 @@ class ReadMcpResourceTool(Tool[ReadMcpResourceInput, ReadMcpResourceOutput]):
                             try:
                                 raw_bytes = base64.b64decode(blob_data)
                             except Exception:
+                                logger.exception(
+                                    "[mcp_tools] Failed to decode base64 blob content",
+                                    extra={"server": input_data.server, "uri": input_data.uri},
+                                )
                                 raw_bytes = None
                         else:
                             raw_bytes = None
@@ -521,8 +530,9 @@ class ReadMcpResourceTool(Tool[ReadMcpResourceInput, ReadMcpResourceOutput]):
                 text_parts = [p.text for p in parts if p.text]
                 content_text = "\n".join([p for p in text_parts if p]) or None
             except Exception as exc:  # pragma: no cover - runtime errors
-                logger.error(
-                    f"Error reading MCP resource {input_data.uri} from {input_data.server}: {exc}"
+                logger.exception(
+                    "Error reading MCP resource",
+                    extra={"server": input_data.server, "uri": input_data.uri, "error": str(exc)},
                 )
                 content_text = f"Error reading MCP resource: {exc}"
         else:
@@ -575,6 +585,7 @@ def _annotation_flag(tool_info: Any, key: str) -> bool:
         try:
             return bool(annotations.get(key, False))
         except Exception:
+            logger.debug("[mcp_tools] Failed to read annotation flag", exc_info=True)
             return False
     return False
 
@@ -718,8 +729,13 @@ class DynamicMcpTool(Tool[BaseModel, McpToolCallOutput]):
                 structured_content=None,
                 is_error=True,
             )
-            logger.error(
-                f"Error calling MCP tool {self.tool_info.name} on {self.server_name}: {exc}"
+            logger.exception(
+                "Error calling MCP tool",
+                extra={
+                    "server": self.server_name,
+                    "tool": self.tool_info.name,
+                    "error": str(exc),
+                },
             )
             yield ToolResult(
                 data=output,
@@ -768,7 +784,10 @@ def load_dynamic_mcp_tools_sync(project_path: Optional[Path] = None) -> List[Dyn
     try:
         return asyncio.run(_load_and_cleanup())
     except Exception as exc:  # pragma: no cover - SDK/runtime failures
-        logger.error(f"Failed to initialize MCP runtime for dynamic tools: {exc}")
+        logger.exception(
+            "Failed to initialize MCP runtime for dynamic tools (sync)",
+            extra={"error": str(exc)},
+        )
         return []
 
 
@@ -777,7 +796,10 @@ async def load_dynamic_mcp_tools_async(project_path: Optional[Path] = None) -> L
     try:
         runtime = await ensure_mcp_runtime(project_path)
     except Exception as exc:  # pragma: no cover - SDK/runtime failures
-        logger.error(f"Failed to initialize MCP runtime for dynamic tools: {exc}")
+        logger.exception(
+            "Failed to initialize MCP runtime for dynamic tools (async)",
+            extra={"error": str(exc)},
+        )
         return []
     return _build_dynamic_mcp_tools(runtime)
 

ripperdoc/tools/multi_edit_tool.py

@@ -17,6 +17,10 @@ from ripperdoc.core.tool import (
     ToolUseExample,
     ValidationResult,
 )
+from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
+
+logger = get_logger()
 
 
 DEFAULT_ACTION = "Edit"
@@ -307,6 +311,10 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
             if existing:
                 original_content = file_path.read_text(encoding="utf-8")
         except Exception as exc:  # pragma: no cover - unlikely permission issue
+            logger.exception(
+                "[multi_edit_tool] Error reading file before edits",
+                extra={"file_path": str(file_path)},
+            )
             output = MultiEditToolOutput(
                 file_path=str(file_path),
                 replacements_made=0,
@@ -353,7 +361,22 @@ class MultiEditTool(Tool[MultiEditToolInput, MultiEditToolOutput]):
         file_path.parent.mkdir(parents=True, exist_ok=True)
         try:
             file_path.write_text(updated_content, encoding="utf-8")
+            try:
+                record_snapshot(
+                    str(file_path),
+                    updated_content,
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[multi_edit_tool] Failed to record file snapshot",
+                    extra={"file_path": str(file_path)},
+                )
         except Exception as exc:
+            logger.exception(
+                "[multi_edit_tool] Error writing edited file",
+                extra={"file_path": str(file_path)},
+            )
             output = MultiEditToolOutput(
                 file_path=str(file_path),
                 replacements_made=0,

ripperdoc/tools/notebook_edit_tool.py

@@ -20,6 +20,7 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.file_watch import record_snapshot
 
 
 logger = get_logger()
@@ -165,8 +166,8 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
         try:
             raw = path.read_text(encoding="utf-8")
             nb_json = json.loads(raw)
-        except Exception as exc:
-            logger.error(f"Failed to parse notebook {path}: {exc}")
+        except Exception:
+            logger.exception("Failed to parse notebook", extra={"path": str(path)})
             return ValidationResult(
                 result=False, message="Notebook is not valid JSON.", error_code=6
             )
@@ -272,6 +273,17 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
             )
 
             path.write_text(json.dumps(nb_json, indent=1), encoding="utf-8")
+            try:
+                record_snapshot(
+                    input_data.notebook_path,
+                    json.dumps(nb_json, indent=1),
+                    getattr(context, "file_state_cache", {}),
+                )
+            except Exception:
+                logger.exception(
+                    "[notebook_edit_tool] Failed to record file snapshot",
+                    extra={"file_path": input_data.notebook_path},
+                )
 
             output = NotebookEditOutput(
                 new_source=new_source,
@@ -285,7 +297,10 @@ class NotebookEditTool(Tool[NotebookEditInput, NotebookEditOutput]):
                 data=output, result_for_assistant=self.render_result_for_assistant(output)
             )
         except Exception as exc:  # pragma: no cover - error path
-            logger.error(f"Error editing notebook {input_data.notebook_path}: {exc}")
+            logger.exception(
+                "Error editing notebook",
+                extra={"path": input_data.notebook_path, "error": str(exc)},
+            )
             output = NotebookEditOutput(
                 new_source=new_source,
                 cell_type=cell_type or "code",

ripperdoc/tools/task_tool.py

@@ -19,6 +19,9 @@ from ripperdoc.core.query import QueryContext, query
 from ripperdoc.core.system_prompt import build_environment_prompt
 from ripperdoc.core.tool import Tool, ToolOutput, ToolProgress, ToolResult, ToolUseContext
 from ripperdoc.utils.messages import AssistantMessage, create_user_message
+from ripperdoc.utils.log import get_logger
+
+logger = get_logger()
 
 
 class TaskToolInput(BaseModel):
@@ -284,6 +287,10 @@ class TaskTool(Tool[TaskToolInput, TaskToolOutput]):
             try:
                 serialized = json.dumps(inp, ensure_ascii=False)
             except Exception:
+                logger.exception(
+                    "[task_tool] Failed to serialize tool_use input",
+                    extra={"tool_use_input": str(inp)},
+                )
                 serialized = str(inp)
             return serialized if len(serialized) <= 120 else serialized[:117] + "..."