virtuai-cli 0.7.2__tar.gz → 0.7.5__tar.gz

{virtuai_cli-0.7.2 → virtuai_cli-0.7.5}/PKG-INFO

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

{virtuai_cli-0.7.2 → virtuai_cli-0.7.5}/pyproject.toml

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

{virtuai_cli-0.7.2 → virtuai_cli-0.7.5}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.7.2"
+__version__ = "0.7.5"

{virtuai_cli-0.7.2 → virtuai_cli-0.7.5}/src/virtuai_cli/chat/tui.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 from pathlib import Path
 from typing import Optional
 
@@ -109,6 +110,12 @@ class ChatApp(App):
         self._runner_task: Optional[asyncio.Task] = None
         self._current_turn: Optional[AssistantTurn] = None
         self._select_mode: bool = False
+        # Persistent state shown in the status bar — refreshed by a periodic
+        # tick so the user always sees current connection + working status.
+        self._connection_state: str = "connecting"   # connecting | live | reconnecting | offline
+        self._streaming: bool = False
+        self._status_message: str = ""
+        self._spinner_idx: int = 0
 
     # ── Layout ────────────────────────────────────────────────────────────
     def compose(self) -> ComposeResult:
@@ -125,39 +132,99 @@ class ChatApp(App):
         yield ChatInput(id="input")
         yield Footer()
 
+    _SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
     def _initial_status(self) -> str:
+        # Composed once for the first paint; the tick timer takes over after mount.
+        return self._compose_status()
+
+    def _compose_status(self) -> str:
         model = f" · {self.current_model_id}" if self.current_model_id else ""
-        return f"{self.workspace_name} · {self.agent_name}{model} · connecting…"
+
+        conn = self._connection_state
+        if conn == "live":
+            conn_part = "[green]● live[/green]"
+        elif conn == "offline":
+            conn_part = "[red]○ offline[/red]"
+        elif conn == "reconnecting":
+            spin = self._SPINNER[self._spinner_idx % len(self._SPINNER)]
+            conn_part = f"[yellow]{spin} reconnecting[/yellow]"
+        else:  # connecting
+            spin = self._SPINNER[self._spinner_idx % len(self._SPINNER)]
+            conn_part = f"[yellow]{spin} connecting[/yellow]"
+
+        if self._streaming:
+            spin = self._SPINNER[self._spinner_idx % len(self._SPINNER)]
+            work_part = f" · [cyan]{spin} working[/cyan]"
+        else:
+            work_part = ""
+
+        msg_part = f" · {self._status_message}" if self._status_message else ""
+        return (
+            f"{self.workspace_name} · {self.agent_name}{model} · "
+            f"{conn_part}{work_part}{msg_part}"
+        )
 
     # ── Mount: start the WS runner in the background ──────────────────────
     async def on_mount(self) -> None:
         self.title = "VirtuAI"
         self.sub_title = f"{self.agent_name} · {self.workspace_name}"
         self.query_one(ChatInput).focus()
+        # 100 ms tick to animate the spinner whenever connection or stream
+        # state needs a moving indicator.
+        self.set_interval(0.1, self._tick_status)
         self._runner_task = asyncio.create_task(self._run_ws())
 
+    def _tick_status(self) -> None:
+        moving = self._streaming or self._connection_state in ("connecting", "reconnecting")
+        if moving:
+            self._spinner_idx = (self._spinner_idx + 1) % len(self._SPINNER)
+        self._refresh_status_bar()
+
+    def _refresh_status_bar(self) -> None:
+        try:
+            self.query_one("#status", Static).update(self._compose_status())
+        except Exception:
+            pass
+
     async def _run_ws(self) -> None:
         def on_status(level: str, msg: str) -> None:
-            # Runner runs on the same event loop, so call directly.
-            self._set_status(msg)
+            low = msg.lower()
+            if low.startswith("connected"):
+                self._connection_state = "live"
+                self._status_message = ""
+            elif low.startswith("connecting"):
+                self._connection_state = "connecting"
+                self._status_message = ""
+            elif low.startswith("disconnected") or "retrying" in low:
+                self._connection_state = "reconnecting"
+                # Keep the runner's "Retrying in Ns…" message as context.
+                self._status_message = msg
+            elif level == "error":
+                self._connection_state = "offline"
+                self._status_message = msg
+            elif level == "exec":
+                # ephemeral one-line preview of what the agent is running
+                self._status_message = f"exec: {msg}"
+            else:
+                self._status_message = msg
+            self._refresh_status_bar()
 
         try:
             await ws_runner.run_forever(self.server_url, self.token, self.workdir, on_status=on_status)
         except asyncio.CancelledError:
+            self._connection_state = "offline"
+            self._refresh_status_bar()
             raise
         except Exception as exc:
-            self._set_status(f"runner error: {exc}")
+            self._connection_state = "offline"
+            self._status_message = f"runner error: {exc}"
+            self._refresh_status_bar()
 
     def _set_status(self, text: str) -> None:
-        # The status widget may have been torn down during app shutdown —
-        # swallow the lookup error so we don't surface a NoMatches on exit.
-        model = f" · {self.current_model_id}" if self.current_model_id else ""
-        try:
-            self.query_one("#status", Static).update(
-                f"{self.workspace_name} · {self.agent_name}{model} · {text}"
-            )
-        except Exception:
-            pass
+        """Set an ephemeral status message — connection/streaming glyphs stay."""
+        self._status_message = text
+        self._refresh_status_bar()
 
     # ── Slash hints / autocomplete ────────────────────────────────────────
     def _matching_commands(self, prefix: str) -> list[tuple[str, str]]:
@@ -535,6 +602,8 @@ class ChatApp(App):
 
     # ── SSE stream → widget mutations ─────────────────────────────────────
     async def _stream_response(self, message: str, turn: AssistantTurn) -> None:
+        self._streaming = True
+        self._refresh_status_bar()
         try:
             async for event in stream_chat(
                 self.server_url,
@@ -556,6 +625,8 @@ class ChatApp(App):
             except Exception:
                 pass
         finally:
+            self._streaming = False
+            self._refresh_status_bar()
             try:
                 await turn.mark_final()
             except Exception:
@@ -585,22 +656,42 @@ class ChatApp(App):
             if content:
                 await turn.append_token(content)
         elif etype == "tool_start":
-            await turn.start_tool(
-                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"),
-            )
+            # Skip tool-call cards whose input is empty — those are the visual
+            # debris of a tool call that was truncated mid-JSON when the model
+            # hit max_tokens. The card has no useful info and clutters the
+            # screen; the accompanying `truncated` event already tells the
+            # story. Empty == "", "{}", or anything that strips to nothing.
+            input_val = event.get("input", "")
+            input_str = input_val if isinstance(input_val, str) else json.dumps(input_val, default=str)
+            if input_str.strip() in ("", "{}", "[]"):
+                turn._tools[event.get("id", "")] = None  # type: ignore[assignment]
+            else:
+                await turn.start_tool(
+                    event.get("id", ""),
+                    event.get("name", "tool"),
+                    input_val,
+                    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)
+            # If we skipped the matching tool_start (empty input), don't try
+            # to finalize a card that doesn't exist.
+            if turn._tools.get(event.get("id", "")) is not None:
+                turn.finish_tool(event.get("id", ""), event.get("output_preview"), errored=False)
         elif etype == "todos":
             await turn.set_todos(event.get("items", []))
         elif etype == "truncated":
-            await turn.append_token("\n\n*[response truncated]*")
+            # Dedupe: when max_tokens hits repeatedly on multiple model passes
+            # in a single turn (e.g. while a big tool-call arg gets retried),
+            # we don't want a wall of `[response truncated]` markers.
+            if not turn._truncated_shown:
+                await turn.append_token(
+                    "\n\n*[response truncated — try raising the agent's max_tokens]*"
+                )
+                turn._truncated_shown = True
         elif etype == "error":
             msg = event.get("error") or event.get("message") or "unknown error"
             await turn.append_token(f"\n\n*[error: {msg}]*")

{virtuai_cli-0.7.2 → virtuai_cli-0.7.5}/src/virtuai_cli/chat/widgets.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import difflib
 import json
 import random
+import re
 import time
 from typing import Any, Optional
 
@@ -83,6 +84,88 @@ class ChatInput(TextArea):
 # rather than a generic ToolCallCard.
 _FILE_DISPLAYS = {"file", "file_written"}
 
+
+# ─── Artifact-tag normalization ──────────────────────────────────────────────
+# The agent emits rich content (mermaid diagrams, code, HTML, SVG) wrapped in
+# <artifact type="..." title="..." language="...">…</artifact> XML tags so the
+# web UI can render them as artifact cards. Terminals can't render mermaid or
+# HTML visually, so we rewrite those tags into fenced markdown code blocks
+# (with a header line) — that way Rich Markdown renders the source as a
+# syntax-highlighted code block instead of either silently swallowing the
+# whole block (HTML-tag handling) or interpreting `[Label]` in mermaid bodies
+# as empty markdown links (which is what reduces "F1[FASE 1] --> F2[…]" to a
+# bare "F1 --> F2 -->").
+
+_ARTIFACT_OPEN_RE = re.compile(r"<artifact([^>]*)>", re.IGNORECASE)
+_ARTIFACT_CLOSE_RE = re.compile(r"</artifact\s*>", re.IGNORECASE)
+_ATTR_RE = re.compile(r"(\w+)=(?:\"([^\"]*?)\"|(\S+))")
+
+
+def _parse_artifact_attrs(raw: str) -> dict[str, str]:
+    return {m.group(1): (m.group(2) if m.group(2) is not None else m.group(3) or "")
+            for m in _ATTR_RE.finditer(raw)}
+
+
+def _artifact_header(attrs: dict[str, str], suffix: str = "") -> str:
+    atype = (attrs.get("type") or "code").strip()
+    title = (attrs.get("title") or "Artifact").strip()
+    icon = {
+        "mermaid": "📈",
+        "html": "🌐",
+        "svg": "🎨",
+        "code": "📄",
+        "markdown": "📝",
+        "pdf": "📕",
+    }.get(atype.lower(), "📎")
+    return f"\n\n**{icon} {atype} · {title}**{suffix}\n"
+
+
+def _artifact_lang(attrs: dict[str, str]) -> str:
+    lang = (attrs.get("language") or attrs.get("lang") or "").strip()
+    if lang:
+        return lang
+    atype = (attrs.get("type") or "").strip().lower()
+    return {"mermaid": "mermaid", "html": "html", "svg": "xml"}.get(atype, "text")
+
+
+def normalize_artifacts(text: str) -> str:
+    """Rewrite <artifact>…</artifact> blocks into fenced code blocks.
+
+    Handles both completed pairs (full body rendered inside a fence) and a
+    trailing unclosed `<artifact …>` left over while the model is still
+    streaming the body (renders with a "(generating…)" marker so the user
+    sees the artifact appear progressively).
+    """
+    if "<artifact" not in text.lower():
+        return text
+
+    out: list[str] = []
+    pos = 0
+    while True:
+        open_m = _ARTIFACT_OPEN_RE.search(text, pos)
+        if not open_m:
+            out.append(text[pos:])
+            break
+        # Emit prose before the opening tag.
+        out.append(text[pos:open_m.start()])
+        attrs = _parse_artifact_attrs(open_m.group(1))
+        lang = _artifact_lang(attrs)
+        body_start = open_m.end()
+        close_m = _ARTIFACT_CLOSE_RE.search(text, body_start)
+        if close_m:
+            body = text[body_start:close_m.start()].strip("\n")
+            out.append(_artifact_header(attrs))
+            out.append(f"```{lang}\n{body}\n```\n")
+            pos = close_m.end()
+        else:
+            # Trailing open tag mid-stream — render what we have so far and stop.
+            body = text[body_start:]
+            out.append(_artifact_header(attrs, suffix="  *(generating…)*"))
+            out.append(f"```{lang}\n{body}\n```\n")
+            pos = len(text)
+            break
+    return "".join(out)
+
 _WRITE_TOOLS = {"write_file", "create_file", "fs_write"}
 
 
@@ -129,7 +212,7 @@ class TextSegment(Static):
 
     def append(self, chunk: str) -> None:
         self._buf += chunk
-        self.update(Markdown(self._buf))
+        self.update(Markdown(normalize_artifacts(self._buf)))
 
     @property
     def content(self) -> str:
@@ -421,11 +504,14 @@ class AssistantTurn(Vertical):
 
     def __init__(self, *, show_thinking: bool = True) -> None:
         super().__init__()
-        self._tools: dict[str, ToolCallCard] = {}
+        # Value is either the card widget OR None when the matching tool_start
+        # was suppressed (empty/truncated args) — see tui.py _handle_event.
+        self._tools: dict[str, Optional[Any]] = {}
         self._todo: Optional[TodoList] = None
         self._last_text: Optional[TextSegment] = None
         self._thinking: Optional[ThinkingIndicator] = None
         self._show_thinking = show_thinking
+        self._truncated_shown: bool = False
         self._final = False
 
     async def on_mount(self) -> None:

{virtuai_cli-0.7.2 → virtuai_cli-0.7.5}/src/virtuai_cli.egg-info/PKG-INFO

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