vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/ui/prompt_history.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from vtx import get_config_dir
+
+MAX_HISTORY_ENTRIES = 50
+
+
+def _history_path() -> Path:
+    return get_config_dir() / "prompt-history.jsonl"
+
+
+class PromptHistory:
+    def __init__(self) -> None:
+        self._entries: list[str] = []
+        self._index: int = 0
+        self._draft: str = ""
+        self._load()
+
+    def _load(self) -> None:
+        path = _history_path()
+        if not path.exists():
+            return
+        try:
+            text = path.read_text(encoding="utf-8")
+        except OSError:
+            return
+        lines: list[str] = []
+        for line in text.strip().split("\n"):
+            if not line:
+                continue
+            try:
+                entry = json.loads(line)
+            except (json.JSONDecodeError, ValueError):
+                continue
+            if isinstance(entry, str) and entry:
+                lines.append(entry)
+        self._entries = lines[-MAX_HISTORY_ENTRIES:]
+        if len(lines) > MAX_HISTORY_ENTRIES:
+            self._rewrite()
+
+    def _rewrite(self) -> None:
+        path = _history_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            content = "\n".join(json.dumps(e) for e in self._entries) + "\n"
+            path.write_text(content, encoding="utf-8")
+        except OSError:
+            pass
+
+    def _append_to_file(self, entry: str) -> None:
+        path = _history_path()
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            with path.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(entry) + "\n")
+        except OSError:
+            pass
+
+    def append(self, text: str) -> None:
+        if not text:
+            return
+        if self._entries and self._entries[-1] == text:
+            self._reset_index()
+            return
+        self._entries.append(text)
+        trimmed = len(self._entries) > MAX_HISTORY_ENTRIES
+        if trimmed:
+            self._entries = self._entries[-MAX_HISTORY_ENTRIES:]
+            self._rewrite()
+        else:
+            self._append_to_file(text)
+        self._reset_index()
+
+    @property
+    def is_browsing(self) -> bool:
+        return self._index != 0
+
+    def _reset_index(self) -> None:
+        self._index = 0
+        self._draft = ""
+
+    def navigate(self, direction: int, current_text: str) -> str | None:
+        if not self._entries:
+            return None
+
+        if self._index == 0:
+            self._draft = current_text
+
+        new_index = self._index + direction
+
+        if new_index > 0 or abs(new_index) > len(self._entries):
+            return None
+
+        self._index = new_index
+
+        if self._index == 0:
+            return self._draft
+
+        return self._entries[self._index]

vtx/ui/queue_ui.py

@@ -0,0 +1,141 @@
+"""Pending/steer message queue state and its QueueDisplay rendering."""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import TYPE_CHECKING, Any
+
+from .input import InputBox
+from .widgets import QueueDisplay
+
+
+class QueueUIMixin:
+    """Manages the two message queues: steer (injected mid-run) and pending (run next)."""
+
+    _pending_queue: deque[tuple[str, str]]
+    _steer_queue: deque[tuple[str, str]]
+    _queue_selection: tuple[bool, int] | None
+    _queue_editing: tuple[bool, int, tuple[str, str]] | None
+
+    if TYPE_CHECKING:
+        query_one: Any
+
+    def _queue_items(self) -> list[tuple[bool, int, str, str]]:
+        steer = [
+            (True, index, display, query)
+            for index, (display, query) in enumerate(self._steer_queue)
+        ]
+        pending = [
+            (False, index, display, query)
+            for index, (display, query) in enumerate(self._pending_queue)
+        ]
+        return steer + pending
+
+    def _selected_queue_flat_index(self) -> int | None:
+        if self._queue_selection is None:
+            return None
+        for flat_index, (is_steer, index, _, _) in enumerate(self._queue_items()):
+            if self._queue_selection == (is_steer, index):
+                return flat_index
+        return None
+
+    def _set_queue_selection_by_flat_index(self, flat_index: int | None) -> None:
+        items = self._queue_items()
+        if flat_index is None or flat_index < 0 or flat_index >= len(items):
+            self._queue_selection = None
+        else:
+            is_steer, index, _, _ = items[flat_index]
+            self._queue_selection = (is_steer, index)
+        self._update_queue_display()
+
+    def _update_queue_display(self) -> None:
+        queue_display = self.query_one("#queue-display", QueueDisplay)
+        steer_items = [(display, True) for display, _ in self._steer_queue]
+        normal_items = [(display, False) for display, _ in self._pending_queue]
+        selected = self._selected_queue_flat_index()
+        editing = None
+
+        if self._queue_editing:
+            is_steer, index, original = self._queue_editing
+            target_items = steer_items if is_steer else normal_items
+            edit_index = min(index, len(target_items))
+            target_items.insert(edit_index, (original[0], is_steer))
+            editing = edit_index if is_steer else len(steer_items) + edit_index
+            selected = editing
+
+        queue_display.update_items(steer_items + normal_items, selected=selected, editing=editing)
+
+    def select_queue_from_input(self, direction: int) -> bool:
+        if self._queue_editing is not None:
+            return False
+        items = self._queue_items()
+        if not items:
+            return False
+        current = self._selected_queue_flat_index()
+        if current is None:
+            next_index = len(items) - 1 if direction < 0 else 0
+        else:
+            next_index = current + direction
+        if next_index < 0 or next_index >= len(items):
+            self._set_queue_selection_by_flat_index(None)
+            return False
+        self._set_queue_selection_by_flat_index(next_index)
+        return True
+
+    def delete_selected_queue_item(self) -> bool:
+        if self._queue_editing is not None or self._queue_selection is None:
+            return False
+        is_steer, index = self._queue_selection
+        queue = self._steer_queue if is_steer else self._pending_queue
+        if index >= len(queue):
+            self._set_queue_selection_by_flat_index(None)
+            return False
+        del queue[index]
+        items = self._queue_items()
+        if items:
+            self._set_queue_selection_by_flat_index(min(index, len(items) - 1))
+        else:
+            self._set_queue_selection_by_flat_index(None)
+        return True
+
+    def start_queue_edit(self) -> bool:
+        if self._queue_selection is None or self._queue_editing is not None:
+            return False
+        is_steer, index = self._queue_selection
+        queue = self._steer_queue if is_steer else self._pending_queue
+        if index >= len(queue):
+            self._set_queue_selection_by_flat_index(None)
+            return False
+        original = queue[index]
+        del queue[index]
+        self._queue_editing = (is_steer, index, original)
+        input_box = self.query_one("#input-box", InputBox)
+        input_box.clear(reset_pastes=False)
+        input_box.insert(original[1])
+        input_box.focus()
+        self._update_queue_display()
+        return True
+
+    def finish_queue_edit(self, display_text: str, query_text: str) -> bool:
+        if self._queue_editing is None:
+            return False
+        is_steer, index, _ = self._queue_editing
+        queue = self._steer_queue if is_steer else self._pending_queue
+        queue.insert(min(index, len(queue)), (display_text, query_text))
+        self._queue_editing = None
+        self._queue_selection = (is_steer, min(index, len(queue) - 1))
+        self._update_queue_display()
+        return True
+
+    def cancel_queue_edit(self) -> bool:
+        if self._queue_editing is None:
+            return False
+        is_steer, index, original = self._queue_editing
+        queue = self._steer_queue if is_steer else self._pending_queue
+        queue.insert(min(index, len(queue)), original)
+        self._queue_editing = None
+        self._queue_selection = (is_steer, min(index, len(queue) - 1))
+        self._update_queue_display()
+        input_box = self.query_one("#input-box", InputBox)
+        input_box.clear(reset_pastes=False)
+        return True

vtx/ui/selection_mode.py

@@ -0,0 +1,18 @@
+from enum import StrEnum
+
+
+class SelectionMode(StrEnum):
+    SESSION = "session"
+    MODEL = "model"
+    THEME = "theme"
+    LOGIN = "login"
+    LOGOUT = "logout"
+    PERMISSIONS = "permissions"
+    THINKING = "thinking"
+    THINKING_LINES = "thinking_lines"
+    COLORED_TOOL_BADGE = "colored_tool_badge"
+    NOTIFICATIONS = "notifications"
+    SETTINGS = "settings"
+    TREE = "tree"
+    API_KEY = "api_key"
+    API_KEY_ACTION = "api_key_action"

vtx/ui/session_ui.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ..core.types import (
+    AssistantMessage,
+    ImageContent,
+    TextContent,
+    ThinkingContent,
+    ToolCall,
+    ToolResultMessage,
+    UserMessage,
+)
+from ..runtime import ConversationRuntime
+from ..session import CompactionEntry, CustomMessageEntry, MessageEntry, Session
+from ..tools import BaseTool, get_tool, tools_by_name
+from .chat import ChatLog
+from .commands import CommandsMixin
+from .input import InputBox
+from .tool_output import escape_tool_output_text, truncate_tool_output_text
+from .widgets import InfoBar, StatusLine, format_path
+
+
+class SessionUIMixin:
+    _cwd: str
+    _hide_thinking: bool
+    _current_block_type: str | None
+    _api_key: str | None
+    _tools: list[BaseTool]
+    _openai_compat_auth_mode: Any
+    _anthropic_compat_auth_mode: Any
+    _runtime: ConversationRuntime
+
+    # Methods from App - declared for type checking
+    if TYPE_CHECKING:
+        query_one: Any
+
+    # Methods from other mixins/main class
+    def _sync_runtime_state(self) -> None: ...
+    def _apply_thinking_level_style(self, level: str) -> None: ...
+
+    def _resolve_system_prompt(self, session: Session | None = None) -> str:
+        return self._runtime.resolve_system_prompt(session)
+
+    def _extract_text_content(self, content: str | list[TextContent | ImageContent]) -> str:
+        if isinstance(content, str):
+            return content
+
+        parts: list[str] = []
+        for part in content:
+            if isinstance(part, TextContent):
+                parts.append(part.text)
+            elif isinstance(part, ImageContent):
+                parts.append("[image]")
+
+        return "".join(parts).strip() or "(no content)"
+
+    def _format_tool_call(self, tool_call: ToolCall) -> str:
+        tool = tools_by_name.get(tool_call.name)
+        if not tool:
+            return json.dumps(tool_call.arguments) if tool_call.arguments else ""
+
+        try:
+            params = tool.params(**tool_call.arguments)
+            return tool.format_call(params)
+        except Exception:
+            return json.dumps(tool_call.arguments) if tool_call.arguments else ""
+
+    def _format_tool_result_text(self, message: ToolResultMessage) -> tuple[str, str | None]:
+        if message.content:
+            parts = [part.text for part in message.content if isinstance(part, TextContent)]
+            full_text = "".join(parts)
+            collapsed_text, truncated = truncate_tool_output_text(full_text)
+            return collapsed_text, escape_tool_output_text(full_text) if truncated else None
+
+        return "", None
+
+    def _render_session_entries(self, session: Session) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        started_tools: set[str] = set()
+
+        for entry in session.active_entries:
+            if isinstance(entry, MessageEntry):
+                message = entry.message
+                if isinstance(message, UserMessage):
+                    chat.add_user_message(self._extract_text_content(message.content))
+                elif isinstance(message, AssistantMessage):
+                    for part in message.content:
+                        if isinstance(part, TextContent) and part.text:
+                            chat.add_content(part.text)
+                        elif isinstance(part, ThinkingContent) and part.thinking:
+                            block = chat.add_thinking(part.thinking)
+                            if self._hide_thinking:
+                                block.add_class("-hidden")
+                        elif isinstance(part, ToolCall):
+                            call_msg = self._format_tool_call(part)
+                            tool = get_tool(part.name)
+                            icon = tool.tool_icon if tool else "→"
+                            chat.start_tool(part.name, part.id, call_msg, icon=icon)
+                            started_tools.add(part.id)
+                elif isinstance(message, ToolResultMessage):
+                    tool_id = message.tool_call_id
+                    if tool_id not in started_tools:
+                        tool = get_tool(message.tool_name)
+                        icon = tool.tool_icon if tool else "→"
+                        chat.start_tool(message.tool_name, tool_id, "", icon=icon)
+                        started_tools.add(tool_id)
+
+                    markup = True
+                    ui_summary = message.ui_summary
+                    ui_details = message.ui_details
+                    ui_details_full = message.ui_details_full
+                    if ui_summary is None and ui_details is None:
+                        ui_details, ui_details_full = self._format_tool_result_text(message)
+
+                    images = [part for part in message.content if isinstance(part, ImageContent)]
+                    chat.set_tool_result(
+                        tool_id,
+                        ui_summary,
+                        ui_details,
+                        not message.is_error,
+                        markup=markup,
+                        ui_details_full=ui_details_full,
+                        images=images or None,
+                    )
+            elif isinstance(entry, CompactionEntry):
+                chat.add_compaction_message(entry.tokens_before)
+            elif isinstance(entry, CustomMessageEntry):
+                target_session_id = str(
+                    (entry.details or {}).get("target_session_id") or ""
+                ).strip()
+                query = str((entry.details or {}).get("query") or "").strip()
+                if entry.custom_type == CommandsMixin.HANDOFF_BACKLINK_TYPE and target_session_id:
+                    chat.add_handoff_link_message(
+                        label="Origin session",
+                        target_session_id=target_session_id,
+                        query=query,
+                        direction="back",
+                    )
+                elif (
+                    entry.custom_type == CommandsMixin.HANDOFF_FORWARD_LINK_TYPE
+                    and target_session_id
+                ):
+                    chat.add_handoff_link_message(
+                        label="Handoff session",
+                        target_session_id=target_session_id,
+                        query=query,
+                        direction="forward",
+                    )
+                elif entry.custom_type == "shell_command":
+                    details = entry.details or {}
+                    command = str(details.get("command") or "")
+                    output = str(details.get("output") or "")
+                    success = bool(details.get("success", True))
+                    tool_id = f"shell-replay-{entry.id}"
+                    chat.start_tool("bash", tool_id, f"$ {command}", icon="$")
+                    chat.set_tool_result(
+                        tool_id, None, output or "(no output)", success, markup=False
+                    )
+                elif entry.display:
+                    chat.add_info_message(entry.content)
+
+    async def _load_session_by_id(self, session_id: str) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        input_box = self.query_one("#input-box", InputBox)
+
+        try:
+            session = Session.continue_by_id(self._cwd, session_id)
+        except Exception as exc:
+            chat.add_info_message(f"Failed to load linked session: {exc}", error=True)
+            input_box.focus()
+            return
+
+        if session.session_file is None:
+            chat.add_info_message(
+                "Failed to load linked session: missing session file", error=True
+            )
+            input_box.focus()
+            return
+
+        await self._load_session(session.session_file)
+
+    async def _load_session(self, session_path: str | Path) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        info_bar = self.query_one("#info-bar", InfoBar)
+        status = self.query_one("#status-line", StatusLine)
+        input_box = self.query_one("#input-box", InputBox)
+
+        try:
+            session = self._runtime.load_session(session_path)
+        except Exception as exc:
+            chat.add_info_message(f"Failed to load session: {exc}", error=True)
+            input_box.focus()
+            return
+
+        self._sync_runtime_state()
+        self._current_block_type = None
+
+        status.reset()
+        token_totals = session.token_totals()
+        info_bar.set_tokens(
+            token_totals.input_tokens,
+            token_totals.output_tokens,
+            token_totals.context_tokens,
+            token_totals.cache_read_tokens,
+            token_totals.cache_write_tokens,
+        )
+        info_bar.set_file_changes(session.file_changes_summary())
+
+        model_info = session.model
+        if model_info:
+            provider, model_id, _ = model_info
+            info_bar.set_model(model_id, provider)
+
+        info_bar.set_thinking_level(self._runtime.thinking_level)
+        self._apply_thinking_level_style(self._runtime.thinking_level)
+
+        await chat.remove_all_children()
+
+        chat.add_session_info(getattr(self, "VERSION", ""))
+
+        if self._runtime.agent:
+            chat.add_loaded_resources(
+                context_paths=[
+                    format_path(f.path) for f in self._runtime.agent.context.agents_files
+                ],
+                skills=self._runtime.agent.context.skills,
+                tools=self._runtime.tools,
+            )
+
+        self._render_session_entries(session)
+        chat.add_info_message("Resumed session")
+        input_box.focus()

vtx/ui/startup.py

@@ -0,0 +1,124 @@
+"""Background startup chores: binary download, update check, file-path scan,
+git-branch refresh and launch warnings."""
+
+from __future__ import annotations
+
+import asyncio
+import glob
+import os
+from typing import TYPE_CHECKING, Any, Literal
+
+from vtx import update_available_binaries
+from vtx.tools_manager import ensure_tools
+from vtx.version import PACKAGE_NAME, VERSION
+
+from ..update_check import get_newer_pypi_version
+from .blocks import LaunchWarning
+from .chat import ChatLog
+from .input import InputBox
+from .widgets import InfoBar
+
+_CHANGELOG_URL = "https://github.com/OEvortex/vtx-coding-agent/blob/main/CHANGELOG.md"
+
+
+class StartupMixin:
+    _cwd: str
+    _fd_path: str | None
+    _is_running: bool
+    _startup_complete: bool
+    _update_notice_shown: bool
+    _pending_update_notice_version: str | None
+    _git_branch_refresh_inflight: bool
+    _launch_warnings: list[LaunchWarning]
+
+    if TYPE_CHECKING:
+        query_one: Any
+        call_later: Any
+
+    async def _refresh_git_branch(self) -> None:
+        # Skip the tick if the previous refresh is still resolving in its thread.
+        if self._git_branch_refresh_inflight:
+            return
+        self._git_branch_refresh_inflight = True
+        try:
+            info_bar = self.query_one("#info-bar", InfoBar)
+            await info_bar.refresh_git_branch()
+        finally:
+            self._git_branch_refresh_inflight = False
+
+    def _scan_file_paths(self) -> list[str]:
+        patterns = [
+            "**/*.py",
+            "**/*.js",
+            "**/*.ts",
+            "**/*.tsx",
+            "**/*.json",
+            "**/*.md",
+            "**/*.yaml",
+            "**/*.yml",
+            "**/*.toml",
+        ]
+        paths = []
+        for pattern in patterns:
+            for path in glob.glob(os.path.join(self._cwd, pattern), recursive=True):
+                rel_path = os.path.relpath(path, self._cwd)
+                if not rel_path.startswith(
+                    (".git", "node_modules", "__pycache__", ".venv", "venv")
+                ):
+                    paths.append(rel_path)
+        return sorted(paths)
+
+    async def _collect_file_paths(self) -> None:
+        """Collect file paths using glob (fallback when fd is unavailable)."""
+        # The recursive glob can take seconds on large repos; keep it off the event loop.
+        paths = await asyncio.to_thread(self._scan_file_paths)
+        self.query_one("#input-box", InputBox).set_file_paths(paths)
+
+    async def _ensure_binaries(self) -> None:
+        paths = await ensure_tools(silent=True)
+        update_available_binaries()
+
+        if not self._fd_path and paths.get("fd"):
+            self._fd_path = paths["fd"]
+            self.query_one("#input-box", InputBox).set_fd_path(self._fd_path)
+
+    async def _check_for_updates(self) -> None:
+        latest = await get_newer_pypi_version(PACKAGE_NAME, VERSION)
+        if latest is None:
+            return
+
+        self._pending_update_notice_version = latest
+        self.call_later(self._show_pending_update_notice_if_idle)
+
+    def _show_pending_update_notice_if_idle(self) -> None:
+        if not self._startup_complete or self._is_running:
+            return
+        if self._update_notice_shown or self._pending_update_notice_version is None:
+            return
+
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.add_update_available_message(
+            self._pending_update_notice_version, changelog_url=_CHANGELOG_URL
+        )
+        self._update_notice_shown = True
+        self._pending_update_notice_version = None
+
+    def _add_launch_warning(
+        self, message: str, *, severity: Literal["warning", "error"] = "warning"
+    ) -> None:
+        cleaned = message.strip()
+        if not cleaned:
+            return
+        self._launch_warnings.append(LaunchWarning(message=cleaned, severity=severity))
+
+    def _flush_launch_warnings(self, chat: ChatLog) -> None:
+        if self._launch_warnings:
+            chat.add_launch_warnings(self._launch_warnings)
+
+    async def _ensure_models_dev(self) -> None:
+        import contextlib
+
+        from ..llm.dynamic_models import _fetch_models_dev
+
+        with contextlib.suppress(Exception):
+            await _fetch_models_dev()