virtuai-cli 0.7.1__tar.gz → 0.7.3__tar.gz

{virtuai_cli-0.7.1 → virtuai_cli-0.7.3}/PKG-INFO

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

{virtuai_cli-0.7.1 → virtuai_cli-0.7.3}/pyproject.toml

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

{virtuai_cli-0.7.1 → virtuai_cli-0.7.3}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.7.1"
+__version__ = "0.7.3"

{virtuai_cli-0.7.1 → virtuai_cli-0.7.3}/src/virtuai_cli/chat/tui.py

@@ -379,17 +379,53 @@ class ChatApp(App):
         )
         await scroll.mount(Static(header))
 
+        loaded_session = self.session_id
         for msg in messages:
             mtype = (msg.get("message_type") or "").lower()
             content = msg.get("content") or ""
+            steps = msg.get("steps") or []
             if mtype in ("user", "human"):
                 await scroll.mount(UserBubble(content))
-            else:
-                turn = AssistantTurn(show_thinking=False)
-                await scroll.mount(turn)
-                if content:
-                    await turn.append_token(content)
-                await turn.mark_final()
+                continue
+
+            turn = AssistantTurn(show_thinking=False)
+            await scroll.mount(turn)
+
+            replayed_visible = False
+            if isinstance(steps, list) and steps:
+                # Replay the original event stream through the same handler
+                # the live stream uses, so tool cards, file diffs, todos,
+                # and subagent traces all re-render identically to when
+                # the turn first ran. Skip lifecycle events that mutate
+                # app state (session_id) or close the stream.
+                for step in steps:
+                    if not isinstance(step, dict):
+                        continue
+                    etype = step.get("type")
+                    if etype in ("start", "done", "complete"):
+                        continue
+                    try:
+                        await self._handle_event(step, turn)
+                        if etype in (
+                            "token", "text_segment", "tool_start", "tool_end",
+                            "todos", "subagent_start", "subagent_end",
+                            "memory_updated", "skill_loaded",
+                        ):
+                            replayed_visible = True
+                    except Exception:
+                        # One bad step shouldn't break the whole replay.
+                        continue
+
+            # Fall back to the persisted final text if there were no steps
+            # (older messages saved before steps tracking) or the steps
+            # rendered nothing visible.
+            if not replayed_visible and content:
+                await turn.append_token(content)
+            await turn.mark_final()
+
+        # Replay's `start` events were skipped, but in case anything else
+        # touched session_id, restore it to the conversation we loaded.
+        self.session_id = loaded_session
         scroll.scroll_end(animate=False)
         self._set_status(f"loaded {self.session_id}")
 

{virtuai_cli-0.7.1 → virtuai_cli-0.7.3}/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:

{virtuai_cli-0.7.1 → virtuai_cli-0.7.3}/src/virtuai_cli.egg-info/PKG-INFO

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