virtuai-cli 0.6.0__tar.gz → 0.6.2__tar.gz

{virtuai_cli-0.6.0 → virtuai_cli-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.6.0
+Version: 0.6.2
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-0.6.0 → virtuai_cli-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.6.0"
+version = "0.6.2"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"

{virtuai_cli-0.6.0 → virtuai_cli-0.6.2}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.6.0"
+__version__ = "0.6.2"

{virtuai_cli-0.6.0 → virtuai_cli-0.6.2}/src/virtuai_cli/chat/tui.py

@@ -484,6 +484,11 @@ class ChatApp(App):
                 event.get("id", ""),
                 event.get("name", "tool"),
                 event.get("input", ""),
+                display=event.get("display", ""),
+                file_content=event.get("file_content"),
+                file_content_before=event.get("file_content_before"),
+                read_offset=event.get("read_offset"),
+                read_limit=event.get("read_limit"),
             )
         elif etype == "tool_end":
             turn.finish_tool(event.get("id", ""), event.get("output_preview"), errored=False)

{virtuai_cli-0.6.0 → virtuai_cli-0.6.2}/src/virtuai_cli/chat/widgets.py

@@ -19,28 +19,11 @@ from textual.containers import Vertical
 from textual.widgets import Static
 
 
-# Tool names the agent uses for file mutations — anything that matches
-# routes through EditPreviewCard instead of the generic ToolCallCard.
-_EDIT_TOOLS = {
-    "edit_file", "str_replace", "str_replace_editor",
-    "str_replace_based_edit_tool", "str_replace_edit",
-}
-_WRITE_TOOLS = {"write_file", "create_file", "fs_write"}
-_READ_TOOLS = {"read_file", "view_file", "cat_file", "fs_read"}
-
+# Server-side displays that should render as an EditPreviewCard (path + diff)
+# rather than a generic ToolCallCard.
+_FILE_DISPLAYS = {"file", "file_written"}
 
-def _parse_tool_args(raw: Any) -> dict:
-    """Coerce a tool-call input (dict, JSON string, or anything else) to a dict."""
-    if isinstance(raw, dict):
-        return raw
-    if isinstance(raw, str):
-        try:
-            parsed = json.loads(raw)
-            if isinstance(parsed, dict):
-                return parsed
-        except (json.JSONDecodeError, ValueError):
-            pass
-    return {}
+_WRITE_TOOLS = {"write_file", "create_file", "fs_write"}
 
 
 # Random gerunds shown by the ThinkingIndicator while the agent is responding.
@@ -117,63 +100,79 @@ class EditPreviewCard(Static):
     _MAX_PREVIEW_LINES = 40
     _MAX_LINE_WIDTH = 200
 
-    def __init__(self, tool_id: str, tool_name: str, args: dict) -> None:
+    def __init__(
+        self,
+        tool_id: str,
+        tool_name: str,
+        path: str,
+        display: str,
+        content_after: Optional[str] = None,
+        content_before: Optional[str] = None,
+        read_offset: Optional[int] = None,
+        read_limit: Optional[int] = None,
+    ) -> None:
         super().__init__()
         self.tool_id = tool_id
         self.tool_name = tool_name
-        self.args = args or {}
+        self.path = path or "(unknown file)"
+        # Avoid Widget.display (reserved CSS property: block/none).
+        self.display_kind = display
+        self.content_after = content_after
+        self.content_before = content_before
+        self.read_offset = read_offset
+        self.read_limit = read_limit
         self.errored = False
         self.done = False
         self._redraw()
 
-    def _path(self) -> str:
-        for key in ("path", "file_path", "filename", "file"):
-            v = self.args.get(key)
-            if v:
-                return str(v)
-        return "(unknown file)"
+    def _range_suffix(self) -> str:
+        """`· lines N-M` suffix when the agent paginated a read_file call."""
+        off = self.read_offset
+        lim = self.read_limit
+        if off is None and lim is None:
+            return ""
+        start = off if isinstance(off, int) else 0
+        if isinstance(lim, int) and lim > 0:
+            return f"  · lines {start}-{start + lim}"
+        return f"  · from line {start}"
 
     def _kind(self) -> str:
-        if self.tool_name in _WRITE_TOOLS:
-            return "Create"
-        if self.tool_name in _EDIT_TOOLS:
-            return "Update"
-        if self.tool_name in _READ_TOOLS:
+        n = (self.tool_name or "").lower()
+        if self.display_kind == "file_written":
+            return "Create" if n in _WRITE_TOOLS else "Update"
+        if self.display_kind == "file":
+            if n in ("ls", "list_files"):
+                return "List"
+            if n == "glob":
+                return "Glob"
             return "Read"
-        return self.tool_name
+        return self.tool_name or "Tool"
 
     def _diff_lines(self) -> tuple[list[tuple[str, str]], int, int]:
         """Return ([(marker, text), ...], added_count, removed_count)."""
-        if self.tool_name in _WRITE_TOOLS:
-            content = str(self.args.get("content", "") or self.args.get("file_text", ""))
-            lines = content.splitlines() or [""]
-            return [("+", l) for l in lines], len(lines), 0
-
-        if self.tool_name in _EDIT_TOOLS:
-            old = str(self.args.get("old_string", "") or self.args.get("old", ""))
-            new = str(self.args.get("new_string", "") or self.args.get("new", ""))
-            old_lines = old.splitlines() if old else []
-            new_lines = new.splitlines() if new else []
-            diff = list(difflib.ndiff(old_lines, new_lines))
+        if not self.content_after:
+            return [], 0, 0
+        if self.content_before is not None:
+            old_lines = self.content_before.splitlines() if self.content_before else []
+            new_lines = self.content_after.splitlines() if self.content_after else []
             rows: list[tuple[str, str]] = []
             added = removed = 0
-            for d in diff:
+            for d in difflib.ndiff(old_lines, new_lines):
                 tag = d[:2]
-                content = d[2:]
+                line = d[2:]
                 if tag == "+ ":
-                    rows.append(("+", content)); added += 1
+                    rows.append(("+", line)); added += 1
                 elif tag == "- ":
-                    rows.append(("-", content)); removed += 1
+                    rows.append(("-", line)); removed += 1
                 elif tag == "  ":
-                    rows.append((" ", content))
-                # ignore '? ' hint lines
+                    rows.append((" ", line))
             return rows, added, removed
-
-        # Read / other — no diff
-        return [], 0, 0
+        # No "before" — render the new content as all-added lines.
+        lines = self.content_after.splitlines() or [""]
+        return [("+", l) for l in lines], len(lines), 0
 
     def _redraw(self) -> None:
-        path = self._path()
+        path = self.path
         kind = self._kind()
         rows, added, removed = self._diff_lines()
 
@@ -185,6 +184,9 @@ class EditPreviewCard(Static):
         header = Text("● ", style=marker_style)
         header.append(kind, style="bold")
         header.append(f"({path})")
+        suffix = self._range_suffix()
+        if suffix:
+            header.append(suffix, style="dim")
 
         body_lines: list[Text] = [header]
         if rows:
@@ -389,14 +391,32 @@ class AssistantTurn(Vertical):
             await self.mount(self._last_text)
         self._last_text.append(content)
 
-    async def start_tool(self, tool_id: str, name: str, input_str: Any) -> None:
+    async def start_tool(
+        self,
+        tool_id: str,
+        name: str,
+        input_val: Any,
+        display: str = "",
+        file_content: Optional[str] = None,
+        file_content_before: Optional[str] = None,
+        read_offset: Optional[int] = None,
+        read_limit: Optional[int] = None,
+    ) -> None:
         await self._stop_thinking()
-        if name in _EDIT_TOOLS or name in _WRITE_TOOLS or name in _READ_TOOLS:
-            args = _parse_tool_args(input_str)
-            card: Any = EditPreviewCard(tool_id, name, args)
+        if display in _FILE_DISPLAYS:
+            # For file ops, the server passes the path as a string in `input`
+            # (already extracted from the tool args) and includes file_content
+            # for writes/edits (+ file_content_before for edits on newer servers).
+            path = input_val if isinstance(input_val, str) else json.dumps(input_val, default=str)
+            card: Any = EditPreviewCard(
+                tool_id, name, path, display,
+                content_after=file_content,
+                content_before=file_content_before,
+                read_offset=read_offset,
+                read_limit=read_limit,
+            )
         else:
-            # Keep the input as a string for the generic tool card.
-            text = input_str if isinstance(input_str, str) else json.dumps(input_str, default=str)
+            text = input_val if isinstance(input_val, str) else json.dumps(input_val, default=str)
             card = ToolCallCard(tool_id, name, text)
         self._tools[tool_id] = card
         await self.mount(card)

{virtuai_cli-0.6.0 → virtuai_cli-0.6.2}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.6.0
+Version: 0.6.2
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary