voidx 1.0.0__py3-none-any.whl

voidx/ui/console_components/streaming.py

@@ -0,0 +1,253 @@
+"""Streaming assistant renderer."""
+
+from __future__ import annotations
+
+import time
+from types import TracebackType
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.text import Text
+
+from voidx.ui.console_components.formatting import _next_spin
+from voidx.ui.dock import dock
+from voidx.ui.events import (
+    AssistantStreamStarted,
+    AssistantStreamCommitted,
+    AssistantStreamDiscarded,
+    AssistantStreamUpdated,
+    StatusFinished,
+    StatusUpdated,
+    ui_events,
+)
+
+
+class StreamingRenderer:
+    """Smooth streaming with Rich Live + Markdown rendering."""
+
+    FLUSH_INTERVAL = 0.05
+
+    def __init__(
+        self,
+        console: Console,
+        debug: bool = True,
+        stream_to_dock: bool = True,
+        agent_id: int = -1,
+    ) -> None:
+        self._console = console
+        self._debug = debug
+        self._stream_to_dock = stream_to_dock
+        self._agent_id = agent_id
+        self._thinking: list[str] = []
+        self._thinking_full: list[str] = []
+        self._accumulated: str = ""
+        self._phase: str = "thinking"
+        self._last_flush: float = 0.0
+        self._live: Live | None = None
+        self._start_time: float = time.monotonic()
+        self._first_text: bool = True
+        self._discard: bool = False
+        stamp = time.time_ns()
+        self._thinking_status_id = f"agent:{agent_id}:thinking:{stamp}"
+        self._streaming_status_id = f"agent:{agent_id}:streaming:{stamp}"
+        self._status_started = False
+        self._streaming_status_started = False
+
+    async def __aenter__(self):
+        self.start()
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None,
+        exc_val: BaseException | None, exc_tb: TracebackType | None,
+    ) -> None:
+        self.done()
+
+    def start(self) -> None:
+        if self._status_started:
+            return
+        self._status_started = True
+        if dock.active and self._stream_to_dock:
+            ui_events.emit_nowait(AssistantStreamStarted(agent_id=self._agent_id))
+            ui_events.emit_nowait(StatusUpdated(
+                agent_id=self._agent_id,
+                status_id=self._thinking_status_id,
+                label="Thinking",
+                detail="",
+                stage="thinking",
+            ))
+
+    def feed_thinking(self, text: str) -> None:
+        self._thinking.append(text)
+        self._thinking_full.append(text)
+        if dock.active and self._stream_to_dock:
+            ui_events.emit_nowait(StatusUpdated(
+                agent_id=self._agent_id,
+                status_id=self._thinking_status_id,
+                label="Thinking",
+                detail=self.get_thinking_text(),
+                stage="thinking",
+            ))
+
+    def feed_text(self, text: str) -> None:
+        if not self._status_started:
+            self.start()
+        if self._thinking and self._phase == "thinking":
+            self._flush_thinking()
+
+        self._phase = "text"
+
+        if self._first_text:
+            self._first_text = False
+            self._start_streaming_status()
+            text = "● " + text.lstrip()
+
+        self._accumulated += text
+
+        if dock.active and self._stream_to_dock:
+            now = time.monotonic()
+            if now - self._last_flush >= self.FLUSH_INTERVAL:
+                if not ui_events.emit_nowait(AssistantStreamUpdated(
+                    agent_id=self._agent_id,
+                    text=self._accumulated,
+                )):
+                    dock.set_stream(self._accumulated)
+                self._last_flush = now
+            return
+
+        if self._live is None:
+            self._live = Live(
+                Markdown(""), console=self._console,
+                refresh_per_second=20, transient=False,
+            )
+            self._live.start()
+
+        now = time.monotonic()
+        if now - self._last_flush >= self.FLUSH_INTERVAL:
+            self._live.update(Markdown(self._accumulated))
+            dock.after_output()
+            self._last_flush = now
+
+    def elapsed(self) -> float:
+        return time.monotonic() - self._start_time
+
+    def discard(self) -> None:
+        """Mark this renderer's output as discarded — don't commit to dock."""
+        self._discard = True
+
+    def done(self) -> str:
+        if self._thinking and self._phase == "thinking":
+            self._flush_thinking()
+
+        self._finish_live_status()
+
+        if self._live:
+            if self._accumulated:
+                self._live.update(Markdown(self._accumulated))
+            self._live.stop()
+            self._live = None
+        elif dock.active:
+            if self._discard:
+                if not ui_events.emit_nowait(AssistantStreamDiscarded(agent_id=self._agent_id)):
+                    dock.discard_stream()
+            else:
+                if self._accumulated:
+                    if not ui_events.emit_nowait(AssistantStreamUpdated(
+                        agent_id=self._agent_id,
+                        text=self._accumulated,
+                    )):
+                        dock.set_stream(self._accumulated)
+                if not ui_events.emit_nowait(AssistantStreamCommitted(agent_id=self._agent_id)):
+                    dock.commit_stream()
+
+        full = self._accumulated
+        if full.startswith("● "):
+            full = full[2:]
+        self._accumulated = ""
+        self._thinking = []
+        self._thinking_full = []
+        self._first_text = True
+        self._status_started = False
+        self._streaming_status_started = False
+        return full
+
+    def get_thinking_text(self) -> str:
+        return "".join(self._thinking_full)
+
+    def get_body_text(self) -> str:
+        return self._accumulated
+
+    THINKING_MAX_LINES = 5
+
+    def _flush_thinking(self) -> None:
+        thinking_text = self.get_thinking_text()
+        if thinking_text.strip():
+            if dock.active:
+                if not ui_events.emit_nowait(StatusUpdated(
+                    agent_id=self._agent_id,
+                    status_id=self._thinking_status_id,
+                    label="Thinking",
+                    detail=thinking_text,
+                    stage="thinking",
+                )):
+                    node = dock.set_status(self._thinking_status_id, "Thinking", thinking_text, stage="thinking")
+                    node.collapsed = False
+                self._thinking = []
+                return
+            lines = thinking_text.split("\n")
+            total = len(lines)
+            def render(console: Console) -> None:
+                if total > self.THINKING_MAX_LINES:
+                    skipped = total - self.THINKING_MAX_LINES
+                    visible = "\n".join(lines[-self.THINKING_MAX_LINES:])
+                    console.print(f"  {_next_spin()} [dim]Thinking… [/dim]", end="")
+                    console.print(f"[dim][{skipped} earlier lines folded][/dim]")
+                else:
+                    visible = thinking_text
+                    console.print(f"  {_next_spin()} [dim]Thinking... [/dim]", end="")
+                console.print(Text(visible, style="dim italic"))
+
+            if not dock.capture(render):
+                render(self._console)
+        self._thinking = []
+
+    def _start_streaming_status(self) -> None:
+        if self._streaming_status_started or not dock.active or not self._stream_to_dock:
+            return
+        self._streaming_status_started = True
+        self._finish_thinking_status()
+        ui_events.emit_nowait(StatusUpdated(
+            agent_id=self._agent_id,
+            status_id=self._streaming_status_id,
+            label="Streaming",
+            detail="",
+            stage="streaming",
+        ))
+
+    def _finish_live_status(self) -> None:
+        if not dock.active or not self._stream_to_dock or not self._status_started:
+            return
+        if self._streaming_status_started:
+            ui_events.emit_nowait(StatusFinished(
+                agent_id=self._agent_id,
+                status_id=self._streaming_status_id,
+            ))
+        else:
+            self._finish_thinking_status()
+
+    def _finish_thinking_status(self) -> None:
+        thinking_text = self.get_thinking_text()
+        if thinking_text.strip():
+            ui_events.emit_nowait(StatusFinished(
+                agent_id=self._agent_id,
+                status_id=self._thinking_status_id,
+                label=f"Thinking for {self.elapsed():.0f}s",
+                detail=thinking_text,
+                remove=False,
+            ))
+            return
+        ui_events.emit_nowait(StatusFinished(
+            agent_id=self._agent_id,
+            status_id=self._thinking_status_id,
+        ))

voidx/ui/diff.py

@@ -0,0 +1,331 @@
+"""Diff parsing and rendering helpers."""
+
+from __future__ import annotations
+
+import difflib
+import re
+import subprocess
+from typing import Literal
+
+from pydantic import BaseModel, Field
+from rich.console import Console
+from rich.markup import escape
+from rich.syntax import Syntax
+
+
+class DiffLine(BaseModel):
+    kind: Literal["context", "add", "remove"]
+    old_lineno: int | None = None
+    new_lineno: int | None = None
+    text: str = ""
+
+
+class DiffHunk(BaseModel):
+    old_start: int
+    old_count: int
+    new_start: int
+    new_count: int
+    section: str = ""
+    lines: list[DiffLine] = Field(default_factory=list)
+
+
+class FileDiff(BaseModel):
+    old_path: str = ""
+    new_path: str = ""
+    path: str = ""
+    operation: Literal["Create", "Update", "Delete"] = "Update"
+    added: int = 0
+    removed: int = 0
+    hunks: list[DiffHunk] = Field(default_factory=list)
+    raw: str = ""
+
+
+class StructuredDiff(BaseModel):
+    files: list[FileDiff] = Field(default_factory=list)
+
+
+def render_diff(console: Console, diff_text: str, title: str = "") -> None:
+    """Render a unified diff with syntax highlighting."""
+    if not diff_text.strip():
+        return
+    if title:
+        console.print(f"[bold]{title}[/bold]")
+    console.print(Syntax(diff_text, "diff", theme="monokai", line_numbers=False))
+
+
+_HUNK_RE = re.compile(r"@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \+(?P<new_start>\d+)(?:,(?P<new_count>\d+))? @@(?P<section>.*)")
+
+
+def parse_unified_diff(diff_text: str) -> StructuredDiff:
+    files: list[FileDiff] = []
+    current: FileDiff | None = None
+    hunk: DiffHunk | None = None
+    old_lineno = 0
+    new_lineno = 0
+
+    for raw in diff_text.splitlines():
+        if raw.startswith("--- "):
+            if current is not None:
+                files.append(current)
+            old_path = _clean_diff_path(raw[4:].strip())
+            current = FileDiff(old_path=old_path, raw=raw)
+            hunk = None
+            continue
+
+        if current is not None:
+            current.raw = f"{current.raw}\n{raw}" if current.raw else raw
+
+        if raw.startswith("+++ ") and current is not None:
+            new_path = _clean_diff_path(raw[4:].strip())
+            current.new_path = new_path
+            current.path = _display_path(current.old_path, new_path)
+            current.operation = _operation(current.old_path, new_path)
+            continue
+
+        match = _HUNK_RE.match(raw)
+        if match and current is not None:
+            hunk = DiffHunk(
+                old_start=int(match.group("old_start")),
+                old_count=int(match.group("old_count") or "1"),
+                new_start=int(match.group("new_start")),
+                new_count=int(match.group("new_count") or "1"),
+                section=match.group("section").strip(),
+            )
+            current.hunks.append(hunk)
+            old_lineno = hunk.old_start
+            new_lineno = hunk.new_start
+            continue
+
+        if hunk is None or current is None:
+            continue
+
+        if raw.startswith("+") and not raw.startswith("+++"):
+            hunk.lines.append(DiffLine(kind="add", new_lineno=new_lineno, text=raw[1:]))
+            current.added += 1
+            new_lineno += 1
+        elif raw.startswith("-") and not raw.startswith("---"):
+            hunk.lines.append(DiffLine(kind="remove", old_lineno=old_lineno, text=raw[1:]))
+            current.removed += 1
+            old_lineno += 1
+        elif raw.startswith(" "):
+            hunk.lines.append(DiffLine(
+                kind="context",
+                old_lineno=old_lineno,
+                new_lineno=new_lineno,
+                text=raw[1:],
+            ))
+            old_lineno += 1
+            new_lineno += 1
+        elif raw.startswith("\\"):
+            continue
+
+    if current is not None:
+        files.append(current)
+    return StructuredDiff(files=files)
+
+
+def render_file_change_lines(file_diff: FileDiff, max_hunks: int = 1, max_lines: int = 8) -> tuple[list[str], bool]:
+    lines = [_summary_line(file_diff)]
+    omitted = False
+    shown_hunks = 0
+    shown_lines = 0
+    language = language_from_path(file_diff.path)
+
+    for hunk in file_diff.hunks:
+        if shown_hunks >= max_hunks:
+            omitted = True
+            break
+        for line in hunk.lines:
+            if shown_lines >= max_lines:
+                omitted = True
+                break
+            lines.append(_render_diff_line(line, language))
+            shown_lines += 1
+        shown_hunks += 1
+        if omitted:
+            break
+
+    return lines, omitted
+
+
+def render_full_file_diff_lines(file_diff: FileDiff) -> list[str]:
+    lines: list[str] = []
+    language = language_from_path(file_diff.path)
+    for hunk in file_diff.hunks:
+        if hunk.section:
+            lines.append(f"[dim]@@ {escape(hunk.section)}[/dim]")
+        for line in hunk.lines:
+            lines.append(_render_diff_line(line, language))
+    return lines
+
+
+def language_from_path(path: str) -> str:
+    suffix = path.rsplit(".", 1)[-1].lower() if "." in path else ""
+    mapping = {
+        "py": "python",
+        "js": "javascript",
+        "jsx": "javascript",
+        "ts": "typescript",
+        "tsx": "typescript",
+        "cpp": "cpp",
+        "cc": "cpp",
+        "cxx": "cpp",
+        "c": "c",
+        "h": "cpp",
+        "hpp": "cpp",
+        "rs": "rust",
+        "go": "go",
+        "java": "java",
+        "json": "json",
+        "toml": "toml",
+        "yaml": "yaml",
+        "yml": "yaml",
+        "md": "markdown",
+        "css": "css",
+        "html": "html",
+    }
+    return mapping.get(suffix, "")
+
+
+def _summary_line(file_diff: FileDiff) -> str:
+    added = f"Added {file_diff.added} line{'s' if file_diff.added != 1 else ''}"
+    removed = f"removed {file_diff.removed} line{'s' if file_diff.removed != 1 else ''}"
+    return f"[dim]└[/dim]  {added}, {removed}"
+
+
+def _render_diff_line(line: DiffLine, language: str = "") -> str:
+    lineno = line.new_lineno if line.kind == "add" else line.old_lineno
+    number = "" if lineno is None else str(lineno)
+    prefix = f"{number:>5} "
+    text = _highlight_code(line.text, language)
+    if line.kind == "add":
+        return f"[on #003b0a][#A3BE8C]{prefix}+[/#A3BE8C]  {text}[/on #003b0a]"
+    if line.kind == "remove":
+        return f"[on #4a0000][#BF616A]{prefix}-[/#BF616A]  {text}[/on #4a0000]"
+    return f"[dim]{prefix}[/dim]   {text}"
+
+
+_TOKEN_RE = re.compile(
+    r"(?P<comment>//.*|#.*)"
+    r"|(?P<string>\"(?:\\.|[^\"\\])*\"|'(?:\\.|[^'\\])*')"
+    r"|(?P<number>\b\d+(?:\.\d+)?\b)"
+    r"|(?P<word>\b[A-Za-z_][A-Za-z0-9_]*\b)"
+)
+
+_COMMON_KEYWORDS = {
+    "and", "as", "async", "await", "break", "case", "catch", "class", "const",
+    "continue", "def", "default", "delete", "do", "else", "enum", "except",
+    "export", "false", "final", "finally", "for", "from", "func", "function",
+    "if", "impl", "import", "in", "interface", "let", "match", "namespace",
+    "new", "none", "nullptr", "package", "private", "protected", "public",
+    "return", "self", "static", "struct", "switch", "this", "throw", "true",
+    "try", "type", "using", "var", "void", "while",
+}
+
+
+def _highlight_code(text: str, language: str) -> str:
+    if not text:
+        return ""
+    if language == "markdown":
+        return escape(text)
+
+    rendered: list[str] = []
+    last = 0
+    for match in _TOKEN_RE.finditer(text):
+        if match.start() > last:
+            rendered.append(escape(text[last:match.start()]))
+        token = match.group(0)
+        kind = match.lastgroup or ""
+        if kind == "comment":
+            rendered.append(f"[#7A7F8A]{escape(token)}[/#7A7F8A]")
+        elif kind == "string":
+            rendered.append(f"[#EBCB8B]{escape(token)}[/#EBCB8B]")
+        elif kind == "number":
+            rendered.append(f"[#B48EFD]{escape(token)}[/#B48EFD]")
+        elif kind == "word" and token.lower() in _COMMON_KEYWORDS:
+            rendered.append(f"[#ff5caa]{escape(token)}[/#ff5caa]")
+        else:
+            rendered.append(escape(token))
+        last = match.end()
+    if last < len(text):
+        rendered.append(escape(text[last:]))
+    return "".join(rendered)
+
+
+def _clean_diff_path(value: str) -> str:
+    path = value.split("\t", 1)[0]
+    if path in {"/dev/null", "dev/null"}:
+        return "/dev/null"
+    if path.startswith("a/") or path.startswith("b/"):
+        return path[2:]
+    return path
+
+
+def _display_path(old_path: str, new_path: str) -> str:
+    if new_path and new_path != "/dev/null":
+        return new_path
+    return old_path
+
+
+def _operation(old_path: str, new_path: str) -> Literal["Create", "Update", "Delete"]:
+    if old_path == "/dev/null":
+        return "Create"
+    if new_path == "/dev/null":
+        return "Delete"
+    return "Update"
+
+
+def make_file_diff(
+    filepath: str,
+    old_content: str,
+    new_content: str,
+    old_label: str = "",
+    new_label: str = "",
+) -> str:
+    """Generate a unified diff between old and new content."""
+    old = old_content.splitlines(keepends=True)
+    new = new_content.splitlines(keepends=True)
+    a = old_label or f"a/{filepath}"
+    b = new_label or f"b/{filepath}"
+    diff = difflib.unified_diff(old, new, fromfile=a, tofile=b)
+    return "".join(diff)
+
+
+def diff_stat(diff_text: str) -> tuple[int, int]:
+    """Return (added, removed) line counts from a unified diff."""
+    added = 0
+    removed = 0
+    for line in diff_text.split("\n"):
+        if line.startswith("+") and not line.startswith("+++"):
+            added += 1
+        elif line.startswith("-") and not line.startswith("---"):
+            removed += 1
+    return added, removed
+
+
+def git_diff(workspace: str, staged: bool = False) -> str:
+    """Get working tree diff via git."""
+    try:
+        args = ["git", "diff"]
+        if staged:
+            args.append("--staged")
+        result = subprocess.run(
+            args, capture_output=True, text=True,
+            cwd=workspace, timeout=10,
+        )
+        return result.stdout
+    except Exception:
+        return ""
+
+
+def git_diff_stat(workspace: str) -> str:
+    """Get git diff --stat summary."""
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--stat"],
+            capture_output=True, text=True,
+            cwd=workspace, timeout=10,
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""