voidx 1.0.0__py3-none-any.whl

voidx/ui/dock_components/nodes.py

@@ -0,0 +1,401 @@
+"""Output node mutation mixin for BottomInputDock."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from rich.markup import escape
+
+from voidx.ui.dock_components.formatting import (
+    _ansi_line,
+    _clean,
+    _markdown_lines,
+    _short_path,
+    _short_value,
+    _strip_ansi_trailing_space,
+    _tail_lines,
+)
+from voidx.ui.tree import OutputNode
+
+
+class DockNodeMixin:
+    def append_startup(
+        self,
+        *,
+        model: str,
+        provider: str,
+        workspace: str,
+        session_title: str,
+        is_new: bool,
+        profile_configured: bool = True,
+    ) -> OutputNode | None:
+        from voidx.ui.startup import render_startup_lines
+
+        lines = render_startup_lines(
+            self._width(),
+            model=model,
+            provider=provider,
+            workspace=workspace,
+            session_title=session_title,
+            is_new=is_new,
+        )
+        if not profile_configured:
+            lines.extend([
+                "[yellow]No profile configured — chat is disabled until you set one up.[/yellow]",
+                "[dim]  Use [cyan]/model new[/cyan] to create a profile interactively[/dim]",
+            ])
+        if not lines:
+            return None
+        node = self._tree.new_node(
+            parent=self._tree.root,
+            node_type="startup",
+            header=lines[0],
+            body_lines=lines[1:],
+            collapsed=False,
+        )
+        self.refresh()
+        return node
+
+    def append_message(self, text: str, *, style: str = "", parent: OutputNode | None = None) -> OutputNode | None:
+        clean = _clean(text)
+        if not clean.strip():
+            return None
+        target = parent or self._tree.root
+        lines = [_strip_ansi_trailing_space(line) for line in (clean.splitlines() or [clean])]
+        header = escape(lines[0])
+        if style:
+            header = f"[{style}]{header}[/]"
+        body_lines = [escape(line) for line in lines[1:]]
+        if style:
+            body_lines = [f"[{style}]{line}[/]" for line in body_lines]
+        node = self._tree.new_node(
+            parent=target,
+            node_type="message",
+            header=header,
+            body_lines=body_lines,
+            collapsed=False,
+        )
+        self.refresh()
+        return node
+
+    def append_error(self, message: str, *, parent: OutputNode | None = None) -> OutputNode | None:
+        clean = _clean(message)
+        if not clean.strip():
+            return None
+        lines = [_strip_ansi_trailing_space(line) for line in (clean.splitlines() or [clean])]
+        node = self._tree.new_node(
+            parent=parent or self._tree.root,
+            node_type="error",
+            header=f"[red]✗ {escape(lines[0])}[/red]",
+            body_lines=[f"[red]  {escape(line)}[/red]" for line in lines[1:]],
+            collapsed=False,
+            status="error",
+        )
+        self.refresh()
+        return node
+
+    def append_ansi(self, text: str, *, parent: OutputNode | None = None) -> OutputNode | None:
+        clean = text.rstrip("\n")
+        if not clean.strip():
+            return None
+        lines = [_strip_ansi_trailing_space(line) for line in (clean.splitlines() or [clean])]
+        node = self._tree.new_node(
+            parent=parent or self._tree.root,
+            node_type="message",
+            header=_ansi_line(lines[0]),
+            body_lines=[_ansi_line(line) for line in lines[1:]],
+            collapsed=False,
+        )
+        self.refresh()
+        return node
+
+    def append_thought(self, text: str, elapsed: float | None = None) -> OutputNode | None:
+        clean = _clean(text).strip()
+        if not clean:
+            return None
+        lines = clean.splitlines()
+        summary = f"Thinking for {elapsed:.0f}s" if elapsed is not None else "Thinking"
+        if lines:
+            summary += f", {len(lines)} line{'s' if len(lines) != 1 else ''}"
+        node = self._tree.new_node(
+            parent=self.ensure_agent(),
+            node_type="thought",
+            header=f"[dim]●[/dim] [dim]{escape(summary)}[/dim]",
+            body_lines=[f"[dim]{escape(line)}[/dim]" for line in lines[-5:]],
+            collapsed=True,
+            meta=summary,
+        )
+        self.refresh()
+        return node
+
+    def start_tool(
+        self,
+        label: str,
+        args: str = "",
+        *,
+        parent: OutputNode | None = None,
+        tool_call_id: str | None = None,
+        tool_name: str = "",
+        raw_args: dict[str, Any] | None = None,
+    ) -> OutputNode:
+        if parent is None:
+            self._settle_stream_for_tool()
+        raw_args = raw_args or {}
+        body_lines: list[str] = []
+        header = f"[bold]{escape(label)}[/]"
+        if tool_name == "bash":
+            command = str(raw_args.get("command") or "")
+            if command:
+                body_lines = _bash_markdown_lines(command, self._markdown_width())
+        elif args:
+            header += f"({args})"
+        parent = parent or self.ensure_agent()
+        tool_body = header
+        self._current_tool = self._tree.new_node(
+            parent=parent,
+            node_type="tool_call",
+            header=f"[#A3BE8C]●[/#A3BE8C] {tool_body}",
+            body_lines=body_lines,
+            status="running",
+            collapsed=True,
+            meta=tool_body,
+            tool_call_id=tool_call_id,
+            payload={"tool_name": tool_name, "args": args, "raw_args": raw_args},
+        )
+        self.refresh()
+        return self._current_tool
+
+    def finish_tool(self, label: str, elapsed: float, ok: bool = True, detail: str = "") -> None:
+        if not self._current_tool:
+            return
+        self.finish_tool_node(self._current_tool, label, elapsed, ok, detail)
+
+    def finish_tool_node(
+        self,
+        node: OutputNode,
+        label: str,
+        elapsed: float,
+        ok: bool = True,
+        detail: str = "",
+    ) -> None:
+        color = "dim" if ok else "red"
+        icon = "●" if ok else "✗"
+        tool_body = node.meta or node.header
+        suffix = f" [dim]({elapsed:.1f}s)[/dim]"
+        if detail:
+            suffix += f" [dim]{detail}[/dim]"
+        node.header = f"[{color}]{icon}[/{color}] {tool_body}{suffix}"
+        node.elapsed = elapsed
+        node.status = "done" if ok else "error"
+        self._tree.mark_dirty()
+        self.refresh()
+
+    def append_tool_result(
+        self,
+        text: str,
+        *,
+        parent: OutputNode | None = None,
+        collapsed: bool = False,
+        tool_call_id: str | None = None,
+    ) -> OutputNode | None:
+        clean = _clean(text)
+        if not clean.strip():
+            return None
+        lines = [_strip_ansi_trailing_space(line) for line in (clean.splitlines() or [clean])]
+        while lines and not _clean(lines[0]).strip():
+            lines.pop(0)
+        while lines and not _clean(lines[-1]).strip():
+            lines.pop()
+        if not lines:
+            return None
+        node = self._tree.new_node(
+            parent=parent or self._current_tool or self._current_agent or self._tree.root,
+            node_type="tool_result",
+            header=escape(lines[0]) if lines else "",
+            body_lines=[escape(line) for line in lines[1:]],
+            collapsed=collapsed,
+            tool_call_id=tool_call_id,
+        )
+        self.refresh()
+        return node
+
+    def append_file_change(
+        self,
+        diff_text: str,
+        *,
+        parent: OutputNode | None = None,
+        tool_call_id: str | None = None,
+        preview_hunks: int = 1,
+        preview_lines: int = 8,
+    ) -> OutputNode | None:
+        from voidx.ui.diff import (
+            parse_unified_diff,
+            render_file_change_lines,
+            render_full_file_diff_lines,
+        )
+
+        parsed = parse_unified_diff(diff_text)
+        if not parsed.files:
+            return self.append_tool_result(
+                diff_text,
+                parent=parent,
+                collapsed=True,
+                tool_call_id=tool_call_id,
+            )
+
+        target = parent or self._current_tool or self._current_agent or self._tree.root
+        first_node: OutputNode | None = None
+        for index, file_diff in enumerate(parsed.files):
+            body_lines, omitted = render_file_change_lines(file_diff, preview_hunks, preview_lines)
+            header = (
+                f"[#A3BE8C]●[/#A3BE8C] "
+                f"[bold]{file_diff.operation}[/bold]({escape(_short_path(file_diff.path))})"
+            )
+            if index == 0 and target.node_type == "tool_call":
+                node = target
+                node.header = header
+                node.body_lines = body_lines
+                node.collapsed = True
+                node.status = "done"
+                node.meta = header
+                if tool_call_id:
+                    node.tool_call_id = tool_call_id
+                node.payload["diff_text"] = diff_text
+            else:
+                node = self._tree.new_node(
+                    parent=target,
+                    node_type="tool_call",
+                    header=header,
+                    body_lines=body_lines,
+                    collapsed=True,
+                    status="done",
+                    meta=header,
+                    tool_call_id=tool_call_id,
+                    payload={"diff_text": diff_text},
+                )
+            full_lines = render_full_file_diff_lines(file_diff)
+            if omitted and full_lines:
+                self._tree.new_node(
+                    parent=node,
+                    node_type="tool_result",
+                    header="[dim]Full diff[/dim]",
+                    body_lines=full_lines,
+                    collapsed=True,
+                )
+            if first_node is None:
+                first_node = node
+        self._tree.mark_dirty()
+        self.refresh()
+        return first_node
+
+    def set_status(
+        self,
+        status_id: str,
+        label: str,
+        detail: str = "",
+        *,
+        parent: OutputNode | None = None,
+        stage: str = "working",
+    ) -> OutputNode:
+        node = self._status_nodes.get(status_id)
+        if node is None:
+            node = self._tree.new_node(
+                parent=parent or self._tree.root,
+                node_type="status",
+                header="",
+                collapsed=False,
+            )
+        self._status_nodes[status_id] = node
+        tick = self._status_ticks.get(status_id, 0)
+        self._status_ticks[status_id] = tick + 1
+        color = "#EBCB8B" if tick % 2 == 0 else "#F6D365"
+        node.header = f"[{color}]●[/{color}] {escape(label)}"
+        clean_detail = _clean(detail).strip()
+        node.body_lines = [f"[dim]{escape(line)}[/dim]" for line in _tail_lines(clean_detail, 5)]
+        node.collapsed = False
+        node.status = "running"
+        node.meta = label
+        self._tree.mark_dirty()
+        self.refresh()
+        return node
+
+    def finish_status(
+        self,
+        status_id: str,
+        *,
+        label: str = "",
+        detail: str = "",
+        ok: bool = True,
+        remove: bool = True,
+    ) -> None:
+        node = self._status_nodes.pop(status_id, None)
+        if node is None:
+            return
+        self._status_ticks.pop(status_id, None)
+        if remove:
+            self._remove_node(node)
+            self.refresh()
+            return
+        color = "dim" if ok else "red"
+        icon = "●" if ok else "✗"
+        text = label or _clean(node.header).strip() or "Done"
+        node.header = f"[{color}]{icon}[/{color}] [dim]{escape(text)}[/dim]"
+        clean_detail = _clean(detail).strip()
+        if clean_detail:
+            node.body_lines = [f"[dim]{escape(line)}[/dim]" for line in _tail_lines(clean_detail, 5)]
+        node.status = "done" if ok else "error"
+        node.collapsed = True
+        node.meta = text
+        self._tree.mark_dirty()
+        self.refresh()
+
+    def show_permission(
+        self,
+        prompt: str,
+        tools: list[dict[str, Any]],
+        *,
+        parent: OutputNode | None = None,
+    ) -> OutputNode:
+        self.clear_permission()
+        body: list[str] = []
+        for index, tool in enumerate(tools, 1):
+            name = str(tool.get("name") or "tool")
+            pattern = str(tool.get("pattern") or "")
+            body.append(escape(f"{index}. {name}"))
+            if pattern and pattern != "*":
+                body.append(escape(f"   target: {pattern}"))
+            args = tool.get("args")
+            if isinstance(args, dict):
+                for key, value in args.items():
+                    body.append(escape(f"   {key}: {_short_value(value)}"))
+        self._permission_node = self._tree.new_node(
+            parent=parent or self._tree.root,
+            node_type="permission",
+            header=f"[yellow]Permission required[/yellow] {escape(prompt)}",
+            body_lines=body,
+            collapsed=False,
+        )
+        self.refresh()
+        return self._permission_node
+
+    def clear_permission(self) -> None:
+        if self._permission_node is None:
+            return
+        self._remove_node(self._permission_node)
+        self._permission_node = None
+        self.refresh()
+
+
+def _bash_markdown_lines(command: str, width: int) -> list[str]:
+    command = command.rstrip("\n")
+    if not command:
+        return []
+    fence = _markdown_fence(command)
+    markdown = f"{fence}bash\n{command}\n{fence}"
+    return [_ansi_line(line) for line in _markdown_lines(markdown, width)]
+
+
+def _markdown_fence(text: str) -> str:
+    runs = [len(match.group(0)) for match in re.finditer(r"`+", text)]
+    return "`" * max(3, max(runs, default=0) + 1)

voidx/ui/dock_components/state.py

@@ -0,0 +1,51 @@
+"""Context-local dock proxy."""
+
+from __future__ import annotations
+
+from contextvars import ContextVar
+from typing import Any
+
+_current_dock: ContextVar[Any | None] = ContextVar("current_dock", default=None)
+
+
+def get_dock() -> Any | None:
+    return _current_dock.get()
+
+
+def set_dock(dock: Any | None) -> None:
+    _current_dock.set(dock)
+
+
+class _DockProxy:
+    @property
+    def active(self) -> bool:
+        d = get_dock()
+        return d.active if d is not None else False
+
+    def __getattr__(self, name):
+        d = get_dock()
+        if d is None:
+            if name in ("active",):
+                return False
+            if name in (
+                "begin_capture",
+                "deactivate",
+                "print",
+                "capture",
+                "start_turn",
+                "set_stream",
+                "start_tool",
+                "tool_output",
+                "append_tool_result",
+                "refresh",
+                "set_mode",
+            ):
+                return lambda *args, **kwargs: None
+            raise RuntimeError(f"No active dock in this context. Cannot access '{name}'.")
+        return getattr(d, name)
+
+    def __bool__(self):
+        return get_dock() is not None
+
+
+dock = _DockProxy()

voidx/ui/event_components/__init__.py

@@ -0,0 +1 @@
+"""Implementation parts for UI events."""

voidx/ui/event_components/schema.py

@@ -0,0 +1,249 @@
+"""Typed UI event schemas."""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UiEventBase(BaseModel):
+    model_config = ConfigDict(frozen=True)
+    agent_id: int = -1
+
+
+class CaptureStarted(UiEventBase):
+    kind: Literal["capture.started"] = "capture.started"
+
+
+class CaptureStopped(UiEventBase):
+    kind: Literal["capture.stopped"] = "capture.stopped"
+
+
+class RefreshRequested(UiEventBase):
+    kind: Literal["refresh.requested"] = "refresh.requested"
+
+
+class ResetRequested(UiEventBase):
+    kind: Literal["reset.requested"] = "reset.requested"
+
+
+class TurnStarted(UiEventBase):
+    kind: Literal["turn.started"] = "turn.started"
+    text: str
+
+
+class StartupShown(UiEventBase):
+    kind: Literal["startup.shown"] = "startup.shown"
+    model: str
+    provider: str
+    workspace: str
+    session_title: str
+    is_new: bool
+    profile_configured: bool = True
+
+
+class MessageAppended(UiEventBase):
+    kind: Literal["message.appended"] = "message.appended"
+    text: str
+    style: str = ""
+
+
+class AnsiAppended(UiEventBase):
+    kind: Literal["ansi.appended"] = "ansi.appended"
+    text: str
+
+
+class MarkdownAppended(UiEventBase):
+    kind: Literal["markdown.appended"] = "markdown.appended"
+    content: str
+
+
+class ThoughtAppended(UiEventBase):
+    kind: Literal["thought.appended"] = "thought.appended"
+    text: str
+    elapsed: float | None = None
+
+
+class WarningAppended(UiEventBase):
+    kind: Literal["warning.appended"] = "warning.appended"
+    message: str
+
+
+class ErrorAppended(UiEventBase):
+    kind: Literal["error.appended"] = "error.appended"
+    message: str
+
+
+class DiffAppended(UiEventBase):
+    kind: Literal["diff.appended"] = "diff.appended"
+    diff_text: str
+    title: str = ""
+
+
+class StatusUpdated(UiEventBase):
+    kind: Literal["status.updated"] = "status.updated"
+    status_id: str
+    label: str
+    detail: str = ""
+    stage: Literal[
+        "analyzing",
+        "thinking",
+        "streaming",
+        "agent_step",
+        "compacting",
+        "waiting_permission",
+        "working",
+    ] = "working"
+    parent_tool_call_id: str = ""
+
+
+class StatusFinished(UiEventBase):
+    kind: Literal["status.finished"] = "status.finished"
+    status_id: str
+    label: str = ""
+    detail: str = ""
+    ok: bool = True
+    remove: bool = True
+
+
+class AssistantStreamStarted(UiEventBase):
+    kind: Literal["assistant_stream.started"] = "assistant_stream.started"
+    stream_id: str = "default"
+
+
+class AssistantStreamUpdated(UiEventBase):
+    kind: Literal["assistant_stream.updated"] = "assistant_stream.updated"
+    text: str
+    stream_id: str = "default"
+
+
+class AssistantStreamCommitted(UiEventBase):
+    kind: Literal["assistant_stream.committed"] = "assistant_stream.committed"
+    stream_id: str = "default"
+
+
+class AssistantStreamDiscarded(UiEventBase):
+    kind: Literal["assistant_stream.discarded"] = "assistant_stream.discarded"
+    stream_id: str = "default"
+
+
+class ToolStarted(UiEventBase):
+    kind: Literal["tool.started"] = "tool.started"
+    tool_call_id: str
+    label: str
+    args: str = ""
+    tool_name: str = ""
+    raw_args: dict[str, Any] = Field(default_factory=dict)
+
+
+class ToolFinished(UiEventBase):
+    kind: Literal["tool.finished"] = "tool.finished"
+    tool_call_id: str
+    label: str
+    elapsed: float
+    ok: bool = True
+    detail: str = ""
+
+
+class ToolResultAppended(UiEventBase):
+    kind: Literal["tool_result.appended"] = "tool_result.appended"
+    tool_call_id: str = ""
+    text: str
+    collapsed: bool = False
+
+
+class FileChangeAppended(UiEventBase):
+    kind: Literal["file_change.appended"] = "file_change.appended"
+    tool_call_id: str = ""
+    diff_text: str
+
+
+class SubagentStarted(UiEventBase):
+    kind: Literal["subagent.started"] = "subagent.started"
+    agent_id: int
+    subagent_id: str
+    name: str
+    description: str = ""
+    parent_agent_id: int = -1
+    parent_tool_call_id: str = ""
+
+
+class SubagentStepStarted(UiEventBase):
+    kind: Literal["subagent_step.started"] = "subagent_step.started"
+    agent_id: int
+    subagent_id: str
+    name: str
+    step: int
+    max_steps: int
+
+
+class SubagentFinished(UiEventBase):
+    kind: Literal["subagent.finished"] = "subagent.finished"
+    agent_id: int
+    subagent_id: str
+    ok: bool = True
+    elapsed: float | None = None
+
+
+class PermissionToolDetail(BaseModel):
+    name: str
+    pattern: str = ""
+    args: dict[str, Any] = Field(default_factory=dict)
+
+
+class PermissionPromptShown(UiEventBase):
+    kind: Literal["permission_prompt.shown"] = "permission_prompt.shown"
+    prompt: str
+    choices: list[tuple[str, str, str]]
+    tools: list[PermissionToolDetail] = Field(default_factory=list)
+
+
+class PermissionPromptCleared(UiEventBase):
+    kind: Literal["permission_prompt.cleared"] = "permission_prompt.cleared"
+
+
+class InputSet(UiEventBase):
+    kind: Literal["input.set"] = "input.set"
+    text: str
+    hints: list[tuple[str, str, bool]] = Field(default_factory=list)
+    cursor_pos: int | None = None
+
+
+class NoticeSet(UiEventBase):
+    kind: Literal["notice.set"] = "notice.set"
+    text: str
+
+
+UiEvent: TypeAlias = (
+    CaptureStarted
+    | CaptureStopped
+    | RefreshRequested
+    | ResetRequested
+    | TurnStarted
+    | StartupShown
+    | MessageAppended
+    | AnsiAppended
+    | MarkdownAppended
+    | ThoughtAppended
+    | WarningAppended
+    | ErrorAppended
+    | DiffAppended
+    | StatusUpdated
+    | StatusFinished
+    | AssistantStreamStarted
+    | AssistantStreamUpdated
+    | AssistantStreamCommitted
+    | AssistantStreamDiscarded
+    | ToolStarted
+    | ToolFinished
+    | ToolResultAppended
+    | FileChangeAppended
+    | SubagentStarted
+    | SubagentStepStarted
+    | SubagentFinished
+    | PermissionPromptShown
+    | PermissionPromptCleared
+    | InputSet
+    | NoticeSet
+)