voidx 1.0.0__py3-none-any.whl

voidx/ui/events.py

@@ -0,0 +1,341 @@
+"""Typed UI event bus for serializing terminal rendering updates."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from dataclasses import dataclass
+from typing import Any
+
+from rich.markdown import Markdown
+from rich.markup import escape
+
+from voidx.ui.dock import BottomInputDock
+from voidx.ui.event_components.schema import (
+    AnsiAppended,
+    AssistantStreamCommitted,
+    AssistantStreamDiscarded,
+    AssistantStreamStarted,
+    AssistantStreamUpdated,
+    CaptureStarted,
+    CaptureStopped,
+    DiffAppended,
+    ErrorAppended,
+    FileChangeAppended,
+    InputSet,
+    MarkdownAppended,
+    MessageAppended,
+    NoticeSet,
+    PermissionPromptCleared,
+    PermissionPromptShown,
+    PermissionToolDetail,
+    RefreshRequested,
+    ResetRequested,
+    StartupShown,
+    StatusFinished,
+    StatusUpdated,
+    SubagentFinished,
+    SubagentStarted,
+    SubagentStepStarted,
+    ThoughtAppended,
+    ToolFinished,
+    ToolResultAppended,
+    ToolStarted,
+    TurnStarted,
+    UiEvent,
+    UiEventBase,
+    WarningAppended,
+)
+from voidx.ui.tree import OutputNode
+
+
+@dataclass
+class _QueuedEvent:
+    event: UiEvent
+    future: asyncio.Future[Any] | None = None
+
+
+class UiEventBus:
+    """Single-consumer async queue for all UI mutations."""
+
+    def __init__(self) -> None:
+        self._queue: asyncio.Queue[_QueuedEvent | None] | None = None
+        self._task: asyncio.Task[None] | None = None
+        self._consumer: DockEventConsumer | None = None
+        self._last_error: BaseException | None = None
+
+    @property
+    def is_running(self) -> bool:
+        return self._task is not None and not self._task.done() and self._queue is not None
+
+    @property
+    def last_error(self) -> BaseException | None:
+        return self._last_error
+
+    def start(self, consumer: DockEventConsumer) -> None:
+        if self.is_running:
+            self._consumer = consumer
+            return
+        self._queue = asyncio.Queue()
+        self._consumer = consumer
+        self._last_error = None
+        self._task = asyncio.create_task(self._run(), name="voidx-ui-event-bus")
+
+    async def emit(self, event: UiEvent) -> bool:
+        if not self.is_running or self._queue is None:
+            return False
+        await self._queue.put(_QueuedEvent(event))
+        return True
+
+    def emit_nowait(self, event: UiEvent) -> bool:
+        if not self.is_running or self._queue is None:
+            return False
+        self._queue.put_nowait(_QueuedEvent(event))
+        return True
+
+    async def request(self, event: UiEvent) -> Any:
+        if not self.is_running or self._queue is None:
+            raise RuntimeError("UI event bus is not running")
+        future: asyncio.Future[Any] = asyncio.get_running_loop().create_future()
+        await self._queue.put(_QueuedEvent(event, future))
+        return await future
+
+    async def drain(self) -> None:
+        if self._queue is not None:
+            await self._queue.join()
+        if self._last_error is not None:
+            raise self._last_error
+
+    async def stop(self) -> None:
+        if self._queue is None or self._task is None:
+            return
+        await self._queue.join()
+        await self._queue.put(None)
+        await self._task
+        self._queue = None
+        self._task = None
+        self._consumer = None
+
+    async def _run(self) -> None:
+        assert self._queue is not None
+        while True:
+            item = await self._queue.get()
+            try:
+                if item is None:
+                    return
+                result = None
+                try:
+                    if self._consumer is None:
+                        raise RuntimeError("UI event bus has no consumer")
+                    result = self._consumer.handle(item.event)
+                    if inspect.isawaitable(result):
+                        result = await result
+                except BaseException as exc:
+                    self._last_error = exc
+                    if item.future is not None and not item.future.done():
+                        item.future.set_exception(exc)
+                else:
+                    if item.future is not None and not item.future.done():
+                        item.future.set_result(result)
+            finally:
+                self._queue.task_done()
+
+
+class DockEventConsumer:
+    """Apply typed events to BottomInputDock in queue order."""
+
+    def __init__(self, target: BottomInputDock) -> None:
+        self._dock = target
+        self._tool_nodes: dict[str, OutputNode] = {}
+        self._agent_nodes: dict[int, OutputNode] = {}
+
+    def handle(self, event: UiEvent) -> Any:
+        if isinstance(event, CaptureStarted):
+            return self._dock.begin_capture()
+        if isinstance(event, CaptureStopped):
+            return self._dock.deactivate()
+        if isinstance(event, RefreshRequested):
+            return self._dock.refresh()
+        if isinstance(event, ResetRequested):
+            self._tool_nodes.clear()
+            self._agent_nodes.clear()
+            return self._dock.reset()
+        if isinstance(event, TurnStarted):
+            self._tool_nodes.clear()
+            self._agent_nodes.clear()
+            return self._dock.start_turn(event.text)
+        if isinstance(event, StartupShown):
+            return self._dock.append_startup(
+                model=event.model,
+                provider=event.provider,
+                workspace=event.workspace,
+                session_title=event.session_title,
+                is_new=event.is_new,
+                profile_configured=event.profile_configured,
+            )
+        if isinstance(event, MessageAppended):
+            return self._dock.append_message(event.text, style=event.style)
+        if isinstance(event, AnsiAppended):
+            return self._dock.append_ansi(event.text)
+        if isinstance(event, MarkdownAppended):
+            return self._dock.capture(lambda console: console.print(Markdown(event.content)))
+        if isinstance(event, ThoughtAppended):
+            return self._dock.append_thought(event.text, event.elapsed)
+        if isinstance(event, WarningAppended):
+            return self._dock.append_message(f"! {event.message}", style="yellow")
+        if isinstance(event, ErrorAppended):
+            return self._dock.append_error(event.message, parent=self._agent_parent(event.agent_id))
+        if isinstance(event, DiffAppended):
+            from voidx.ui.diff import render_diff
+
+            return self._dock.capture(lambda console: render_diff(console, event.diff_text, event.title))
+        if isinstance(event, StatusUpdated):
+            return self._dock.set_status(
+                event.status_id,
+                event.label,
+                event.detail,
+                parent=self._status_parent(event),
+                stage=event.stage.replace("_", " "),
+            )
+        if isinstance(event, StatusFinished):
+            return self._dock.finish_status(
+                event.status_id,
+                label=event.label,
+                detail=event.detail,
+                ok=event.ok,
+                remove=event.remove,
+            )
+        if isinstance(event, AssistantStreamStarted):
+            return self._dock.set_stream("", parent=self._stream_parent(event.agent_id))
+        if isinstance(event, AssistantStreamUpdated):
+            return self._dock.set_stream(event.text, parent=self._stream_parent(event.agent_id))
+        if isinstance(event, AssistantStreamCommitted):
+            return self._dock.commit_stream()
+        if isinstance(event, AssistantStreamDiscarded):
+            return self._dock.discard_stream()
+        if isinstance(event, ToolStarted):
+            parent = self._agent_parent(event.agent_id)
+            node = self._dock.start_tool(
+                event.label,
+                event.args,
+                parent=parent,
+                tool_call_id=event.tool_call_id,
+                tool_name=event.tool_name,
+                raw_args=event.raw_args,
+            )
+            self._tool_nodes[event.tool_call_id] = node
+            return node
+        if isinstance(event, ToolFinished):
+            node = self._tool_nodes.get(event.tool_call_id)
+            if node is None:
+                self._dock.finish_tool(event.label, event.elapsed, event.ok, event.detail)
+                return None
+            return self._dock.finish_tool_node(node, event.label, event.elapsed, event.ok, event.detail)
+        if isinstance(event, ToolResultAppended):
+            parent = self._tool_nodes.get(event.tool_call_id) if event.tool_call_id else None
+            if parent is None:
+                parent = self._stream_parent(event.agent_id)
+            return self._dock.append_tool_result(
+                event.text,
+                parent=parent,
+                collapsed=event.collapsed,
+                tool_call_id=event.tool_call_id or None,
+            )
+        if isinstance(event, FileChangeAppended):
+            parent = self._tool_nodes.get(event.tool_call_id) if event.tool_call_id else None
+            if parent is None:
+                parent = self._stream_parent(event.agent_id)
+            return self._dock.append_file_change(
+                event.diff_text,
+                parent=parent,
+                tool_call_id=event.tool_call_id or None,
+            )
+        if isinstance(event, SubagentStepStarted):
+            parent = self._agent_parent(event.agent_id)
+            return self._dock.set_status(
+                f"agent:{event.agent_id}:progress",
+                f"{event.name} ({event.step}/{event.max_steps})",
+                parent=parent,
+                stage="agent step",
+            )
+        if isinstance(event, SubagentStarted):
+            parent = self._tool_nodes.get(event.parent_tool_call_id)
+            if parent is not None:
+                parent.collapsed = False
+            if parent is None and event.parent_agent_id >= 0:
+                parent = self._agent_parent(event.parent_agent_id)
+            if parent is None:
+                parent = self._dock.ensure_agent()
+            body_lines = []
+            if event.description:
+                body_lines.append(f"[dim]Task:[/dim] {escape(event.description)}")
+            body_lines.append(f"[dim]Agent ID:[/dim] {event.agent_id}")
+            node = self._dock.tree.new_node(
+                parent=parent,
+                node_type="subagent",
+                header=f"[#B48EAD]●[/#B48EAD] [bold]{escape(event.name)}[/bold] agent",
+                body_lines=body_lines,
+                collapsed=False,
+                agent_name=event.name,
+                agent_run_id=event.subagent_id,
+                payload={"role_name": event.name, "description": event.description},
+            )
+            self._agent_nodes[event.agent_id] = node
+            self._dock.refresh()
+            return node
+        if isinstance(event, SubagentFinished):
+            node = self._agent_parent(event.agent_id)
+            label = "completed" if event.ok else "failed"
+            elapsed = f" ({event.elapsed:.1f}s)" if event.elapsed is not None else ""
+            self._dock.finish_status(f"agent:{event.agent_id}:progress")
+            if node is None:
+                return None
+            color = "dim" if event.ok else "red"
+            icon = "●" if event.ok else "✗"
+            role_name = str(node.payload.get("role_name") or node.agent_name or event.subagent_id)
+            node.header = f"[{color}]{icon}[/{color}] [{color}]{escape(role_name)} agent {label}{elapsed}[/{color}]"
+            node.status = "done" if event.ok else "error"
+            node.elapsed = event.elapsed
+            node.collapsed = False
+            self._dock.tree.mark_dirty()
+            self._dock.refresh()
+            return node
+        if isinstance(event, InputSet):
+            return self._dock.set_input(event.text, event.hints, event.cursor_pos)
+        if isinstance(event, (PermissionPromptShown, PermissionPromptCleared, NoticeSet)):
+            return None
+        raise TypeError(f"Unsupported UI event: {event!r}")
+
+    def _status_parent(self, event: StatusUpdated) -> OutputNode | None:
+        if event.parent_tool_call_id:
+            node = self._tool_nodes.get(event.parent_tool_call_id)
+            if node is not None:
+                return node
+        if event.agent_id >= 0:
+            return self._agent_parent(event.agent_id)
+        return None
+
+    def _stream_parent(self, agent_id: int) -> OutputNode | None:
+        if agent_id >= 0:
+            return self._agent_parent(agent_id)
+        return None
+
+    def _agent_parent(self, agent_id: int) -> OutputNode | None:
+        if agent_id < 0:
+            return None
+        node = self._agent_nodes.get(agent_id)
+        if node is not None:
+            return node
+        node = self._dock.tree.new_node(
+            parent=self._dock.ensure_agent(),
+            node_type="subagent",
+            header=f"[#B48EAD]●[/#B48EAD] [bold]child agent {agent_id}[/bold]",
+            collapsed=False,
+            agent_name=f"agent {agent_id}",
+        )
+        self._agent_nodes[agent_id] = node
+        self._dock.refresh()
+        return node
+
+
+ui_events = UiEventBus()

voidx/ui/session_changes.py

@@ -0,0 +1,163 @@
+"""Turn-level file change tracker for the review bar."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from voidx.tools.base import resolve_safe
+
+
+@dataclass
+class FileChangeRecord:
+    path: str
+    added: int
+    removed: int
+
+
+@dataclass
+class FileSnapshot:
+    path: str
+    resolved_path: Path
+    existed: bool
+    content: bytes
+
+
+@dataclass
+class RollbackResult:
+    restored: list[str]
+    removed: list[str]
+    errors: list[str]
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+
+class SessionChangeTracker:
+    def __init__(self) -> None:
+        self._files: dict[str, FileChangeRecord] = {}
+        self._snapshots: dict[str, FileSnapshot] = {}
+        self._workspace = "."
+        self._visible = False
+
+    def begin_turn(self, workspace: str) -> None:
+        self._workspace = workspace
+        self._files.clear()
+        self._snapshots.clear()
+        self._visible = False
+
+    def finish_turn(self) -> None:
+        self._visible = True
+
+    def capture_tool_call(
+        self,
+        tool_name: str,
+        args: dict,
+        workspace: str,
+        extra_paths: list[str] | None = None,
+    ) -> None:
+        if tool_name not in {"write", "edit", "lsp_format"}:
+            return
+        file_path = args.get("file_path")
+        if not isinstance(file_path, str) or not file_path:
+            return
+        self.capture_file(file_path, workspace, extra_paths)
+
+    def capture_file(
+        self,
+        file_path: str,
+        workspace: str | None = None,
+        extra_paths: list[str] | None = None,
+    ) -> None:
+        workspace = workspace or self._workspace
+        resolved = resolve_safe(workspace, file_path, extra_paths)
+        if resolved is None:
+            return
+        key = str(resolved)
+        if key in self._snapshots:
+            return
+        existed = resolved.exists() and resolved.is_file()
+        content = resolved.read_bytes() if existed else b""
+        self._snapshots[key] = FileSnapshot(
+            path=self._display_path(resolved, file_path, workspace),
+            resolved_path=resolved,
+            existed=existed,
+            content=content,
+        )
+
+    def record_diff(self, diff_text: str) -> None:
+        from voidx.ui.diff import parse_unified_diff
+
+        parsed = parse_unified_diff(diff_text)
+        for fd in parsed.files:
+            key = fd.path
+            if key in self._files:
+                existing = self._files[key]
+                existing.added += fd.added
+                existing.removed += fd.removed
+            else:
+                self._files[key] = FileChangeRecord(
+                    path=fd.path,
+                    added=fd.added,
+                    removed=fd.removed,
+                )
+
+    def rollback_current(self) -> RollbackResult:
+        restored: list[str] = []
+        removed: list[str] = []
+        errors: list[str] = []
+
+        for snapshot in self._snapshots.values():
+            try:
+                if snapshot.existed:
+                    snapshot.resolved_path.parent.mkdir(parents=True, exist_ok=True)
+                    snapshot.resolved_path.write_bytes(snapshot.content)
+                    restored.append(snapshot.path)
+                elif snapshot.resolved_path.exists():
+                    if snapshot.resolved_path.is_file():
+                        snapshot.resolved_path.unlink()
+                        removed.append(snapshot.path)
+                    else:
+                        errors.append(f"{snapshot.path}: path exists but is not a file")
+            except Exception as exc:
+                errors.append(f"{snapshot.path}: {exc}")
+
+        if not errors:
+            self.clear()
+        return RollbackResult(restored=restored, removed=removed, errors=errors)
+
+    @property
+    def files(self) -> list[FileChangeRecord]:
+        return list(self._files.values())
+
+    @property
+    def file_count(self) -> int:
+        return len(self._files)
+
+    @property
+    def total_added(self) -> int:
+        return sum(f.added for f in self._files.values())
+
+    @property
+    def total_removed(self) -> int:
+        return sum(f.removed for f in self._files.values())
+
+    @property
+    def has_changes(self) -> bool:
+        return self._visible and len(self._files) > 0
+
+    def clear(self) -> None:
+        self._files.clear()
+        self._snapshots.clear()
+        self._visible = False
+
+    @staticmethod
+    def _display_path(resolved: Path, original: str, workspace: str) -> str:
+        try:
+            return str(resolved.relative_to(Path(workspace).resolve()))
+        except ValueError:
+            return original
+
+
+session_tracker = SessionChangeTracker()

voidx/ui/startup.py

@@ -0,0 +1,161 @@
+"""Startup screen — Claude Code style terminal UI."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from rich.cells import cell_len
+from rich.markup import escape
+
+
+class StartupConsole(Protocol):
+    width: int
+
+    def print(self, *args, **kwargs) -> None: ...
+
+
+def show_startup(
+    console: StartupConsole,
+    model: str,
+    provider: str,
+    workspace: str,
+    session_title: str,
+    is_new: bool,
+) -> None:
+    """Render the Claude Code style startup banner."""
+
+    console.print("\n".join(render_startup_lines(
+        console.width,
+        model=model,
+        provider=provider,
+        workspace=workspace,
+        session_title=session_title,
+        is_new=is_new,
+    )))
+
+
+def render_startup_lines(
+    console_width: int,
+    *,
+    model: str,
+    provider: str,
+    workspace: str,
+    session_title: str,
+    is_new: bool,
+) -> list[str]:
+    """Build Rich-markup startup banner lines."""
+
+    from voidx import __version__
+    import os
+
+    folder_name = os.path.basename(workspace) or workspace
+
+    greeting = "Welcome back!" if not is_new else "Welcome to voidx!"
+    session_line = "New session" if is_new else f"Resumed: {session_title or 'previous session'}"
+    info: list[tuple[str, str]] = [
+        ("greeting", greeting),
+        ("model", f"● Model  {provider}/{model}"),
+        ("folder", f"▣ Workspace  {folder_name}"),
+        ("session", f"↳ {session_line}"),
+        ("hint", "Ask anything · / commands · /model switch · Ctrl+J newline"),
+        ("hint", "wheel/click transcript · @ attach · Ctrl+V image"),
+    ]
+
+    title = f"voidx v{__version__}"
+    logo = _cat_logo()
+    logo_plain = [plain for plain, _ in logo]
+    width = _banner_width(console_width, title, logo_plain, [line for _, line in info])
+    logo_width = max(cell_len(line) for line in logo_plain)
+    info_width = max(width - logo_width - 4, 16)
+
+    rendered: list[str] = []
+    title_gap = max(width - cell_len(title) - 1, 0)
+    rendered.append(f"[dim]╭─ {escape(title)} {'─' * title_gap}╮[/dim]")
+    for idx in range(max(len(logo), len(info))):
+        left, styled_left = logo[idx] if idx < len(logo) else ("", "")
+        item = info[idx] if idx < len(info) else ("", "")
+        right = _fit_cell(item[1], info_width)
+        plain = f"{left}{' ' * (logo_width - cell_len(left) + 4)}{right}"
+        pad = max(width - cell_len(plain), 0)
+        rendered.append(
+            f"[dim]│[/dim] {styled_left}"
+            f"{' ' * (logo_width - cell_len(left) + 4)}"
+            f"{_style_info(item[0], right)}"
+            f"{' ' * pad} [dim]│[/dim]"
+        )
+    rendered.append(f"[dim]╰{'─' * (width + 2)}╯[/dim]")
+
+    return rendered
+
+
+def _cat_logo() -> list[tuple[str, str]]:
+    outline = "#8B6F62"
+    eye = "#F2D6A2"
+    bubble = "#C9B79A"
+    return [
+        (
+            "       o     O        ",
+            f"[{bubble}]       o     O        [/]",
+        ),
+        (
+            "    /\\________/\\    ╭╮",
+            f"[{outline}]    /\\________/\\    ╭╮[/]",
+        ),
+        (
+            "   /  ◒      ◒  \\___││",
+            f"[{outline}]   /  [/][{eye}]◒      ◒[/][{outline}]  \\___││[/]",
+        ),
+        (
+            "  |   ▔      ▔      \\││",
+            f"[{outline}]  |   [/][{eye}]▔      ▔[/][{outline}]      \\││[/]",
+        ),
+        (
+            "  |                __╰╯",
+            f"[{outline}]  |                __╰╯[/]",
+        ),
+        (
+            "   \\______________/    ",
+            f"[{outline}]   \\______________/    [/]",
+        ),
+    ]
+
+
+def _banner_width(console_width: int, title: str, logo: list[str], info: list[str]) -> int:
+    logo_width = max(cell_len(line) for line in logo)
+    info_width = max(cell_len(line) for line in info)
+    content_width = max(logo_width + 4 + info_width, cell_len(title) + 4)
+    return min(content_width, max(console_width - 4, 44))
+
+
+def _fit_cell(text: str, width: int) -> str:
+    if cell_len(text) <= width:
+        return text
+    if width <= 3:
+        return "." * max(width, 0)
+    out = ""
+    used = 0
+    for char in text:
+        char_width = cell_len(char)
+        if used + char_width > width - 3:
+            break
+        out += char
+        used += char_width
+    return out + "..."
+
+
+def _style_info(kind: str, text: str) -> str:
+    escaped = escape(text)
+    if kind == "greeting":
+        return f"[bold white]{escaped}[/bold white]"
+    if kind == "model":
+        if text.startswith("● Model  "):
+            return f"[#A3BE8C]●[/#A3BE8C] [dim]Model  [/dim][bold]{escape(text[9:])}[/bold]"
+        return f"[bold]{escaped}[/bold]"
+    if kind == "folder":
+        prefix = "▣ Workspace  "
+        if text.startswith(prefix):
+            return f"[dim]▣ Workspace  [/dim][cyan]{escape(text[len(prefix):])}[/cyan]"
+    if kind == "session":
+        if text.startswith("↳ "):
+            return f"[dim]↳ [/dim][cyan]{escape(text[2:])}[/cyan]"
+    return f"[dim]{escaped}[/dim]"