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

vtx/ui/commands/sessions.py

@@ -0,0 +1,388 @@
+"""Session lifecycle commands: /clear, /new, /resume, /tree, /session, /handoff,
+/compact, /export and /copy."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from pathlib import Path
+
+from vtx import config
+
+from ...session import Session, SessionInfo
+from ..chat import ChatLog
+from ..clipboard import copy_to_clipboard
+from ..floating_list import FloatingList, ListItem
+from ..input import InputBox
+from ..selection_mode import SelectionMode
+from ..tree import TreeSelector
+from ..widgets import InfoBar, StatusLine, format_path
+from .base import CommandSupport
+
+
+class SessionCommands(CommandSupport):
+    HANDOFF_BACKLINK_TYPE = "handoff_backlink"
+    HANDOFF_FORWARD_LINK_TYPE = "handoff_forward_link"
+
+    def _clear_conversation(self) -> None:
+        if self._runtime.session:
+            self._runtime.new_session()
+            self._sync_runtime_state()
+            info_bar = self.query_one("#info-bar", InfoBar)
+            info_bar.set_tokens(0, 0, 0, 0)
+            info_bar.set_file_changes({})
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.add_info_message("Conversation cleared")
+
+    def _new_conversation(self) -> None:
+        self._runtime.new_session()
+        self._sync_runtime_state()
+
+        chat = self.query_one("#chat-log", ChatLog)
+        info_bar = self.query_one("#info-bar", InfoBar)
+        status = self.query_one("#status-line", StatusLine)
+
+        self.run_worker(self._do_new_conversation(chat, info_bar, status), exclusive=False)
+
+    async def _do_new_conversation(self, chat: ChatLog, info_bar, status) -> None:
+        await self._reset_session_ui(chat, info_bar, status)
+        chat.add_info_message("Started new conversation")
+
+    async def _reset_session_ui(self, chat: ChatLog, info_bar, status) -> None:
+        await chat.remove_all_children()
+
+        status.reset()
+
+        info_bar.set_tokens(0, 0, 0, 0)
+        info_bar.set_file_changes({})
+        info_bar.set_thinking_level(self._runtime.thinking_level)
+
+        chat.add_session_info(getattr(self, "VERSION", ""))
+
+        self._runtime.reload_context()
+        self._sync_runtime_state()
+        if self._runtime.agent is not None:
+            self._sync_slash_commands()
+            # TODO: Surface self._runtime.agent.context.skill_warnings in UI
+            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,
+            )
+
+    def _handle_handoff_command(self, args: str) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if self._is_running:
+            chat.add_info_message("Cannot handoff while agent is running", error=True)
+            return
+
+        if (
+            self._runtime.provider is None
+            or self._runtime.session is None
+            or self._runtime.agent is None
+        ):
+            chat.add_info_message("Agent not initialized", error=True)
+            return
+
+        query = args.strip()
+        if not query:
+            chat.add_info_message(
+                "Usage: /handoff <query>. Example: /handoff implement phase two", error=True
+            )
+            return
+
+        if not self._runtime.session.all_messages:
+            chat.add_info_message("No conversation to handoff", error=True)
+            return
+
+        chat.show_spinner_status("Creating handoff...")
+        self.run_worker(self._do_handoff(query), exclusive=False)
+
+    def _resolve_system_prompt(self, session: Session | None = None) -> str:
+        return self._runtime.resolve_system_prompt(session)
+
+    def _create_new_session(self) -> Session:
+        return self._runtime.create_session()
+
+    async def _do_handoff(self, query: str) -> 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)
+
+        if (
+            self._runtime.provider is None
+            or self._runtime.session is None
+            or self._runtime.agent is None
+        ):
+            chat.add_info_message("Agent not initialized", error=True)
+            return
+
+        try:
+            result = await self._runtime.create_handoff(query)
+        except Exception as e:
+            chat.show_status("Handoff failed")
+            chat.add_info_message(f"Handoff failed: {e}", error=True)
+            return
+
+        self._sync_runtime_state()
+        await self._reset_session_ui(chat, info_bar, status)
+        self._render_session_entries(result.new_session)
+
+        input_box.clear()
+        input_box.insert(result.prompt)
+        chat.show_status("Handoff ready")
+        input_box.focus()
+
+    def _show_session_info(self) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        if not self._runtime.session:
+            chat.add_info_message("No active session")
+            return
+
+        session_path = self._runtime.session.session_file
+        session_dir = str(session_path.parent) if session_path else None
+        session_file = session_path.name if session_path else "(in-memory session)"
+
+        counts = self._runtime.session.message_counts()
+        token_totals = self._runtime.session.token_totals()
+
+        chat.add_session_details(
+            session_dir=session_dir,
+            session_file=session_file,
+            user_messages=counts.user_messages,
+            assistant_messages=counts.assistant_messages,
+            tool_calls=counts.tool_calls,
+            tool_results=counts.tool_results,
+            total_messages=counts.total_messages,
+            input_tokens=token_totals.input_tokens,
+            output_tokens=token_totals.output_tokens,
+            cache_read_tokens=token_totals.cache_read_tokens,
+            cache_write_tokens=token_totals.cache_write_tokens,
+            total_tokens=token_totals.total_tokens,
+        )
+
+    def _build_resume_items(self) -> list[ListItem]:
+        sessions = Session.list(self._cwd)
+
+        # Build tree structure from handoff relationships
+        by_id: dict[str, SessionInfo] = {s.id: s for s in sessions}
+        children: dict[str, list[SessionInfo]] = {}
+        roots: list[SessionInfo] = []
+
+        for session in sessions:
+            pid = session.parent_session_id
+            if pid and pid in by_id:
+                children.setdefault(pid, []).append(session)
+            else:
+                roots.append(session)
+
+        # Sort children within each parent by modified time (newest first,
+        # matching the root-level sort from Session.list)
+        for kids in children.values():
+            kids.sort(key=lambda s: s.modified, reverse=True)
+
+        # DFS flatten: roots are already sorted by modified (from Session.list)
+        items: list[ListItem] = []
+        accent = config.ui.colors.accent
+
+        def _walk(node: SessionInfo, depth: int) -> None:
+            prefix = ""
+            if depth > 0:
+                prefix = f"{'   ' * (depth - 1)} └ [handoff] "
+            label = self._format_session_label(node.first_message)
+            caption = f"{self._format_session_age(node.modified)} {node.message_count}"
+            items.append(
+                ListItem(
+                    value=node,
+                    label=label,
+                    description=caption,
+                    prefix=prefix,
+                    prefix_style=accent,
+                )
+            )
+            for child in children.get(node.id, []):
+                _walk(child, depth + 1)
+
+        for root in roots:
+            _walk(root, 0)
+
+        return items
+
+    def _show_tree_selector(self) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        input_box = self.query_one("#input-box", InputBox)
+        if self._is_running:
+            chat.add_info_message("Cannot open tree while agent is running", error=True)
+            return
+        if not self._runtime.session or not self._runtime.session.all_entries:
+            chat.add_info_message("No entries in session")
+            return
+        tree = self._runtime.session.get_tree()
+        selector = self.query_one("#tree-selector", TreeSelector)
+        input_box.clear()
+        input_box.set_autocomplete_enabled(False)
+        input_box.set_completing(True)
+        size = getattr(self, "size", None)
+        height = size.height if size is not None else 24
+        selector.show(tree, self._runtime.session.leaf_id, height)
+        self._selection_mode = SelectionMode.TREE
+
+    def _show_resume_sessions(self) -> None:
+        items = self._build_resume_items()
+        if not items:
+            self.notify(
+                "No saved sessions found", title="Sessions", timeout=3, severity="information"
+            )
+            return
+
+        self._show_selection_picker(items, SelectionMode.SESSION, max_label_width=87)
+
+    def _delete_selected_resume_session(self) -> None:
+        if self._selection_mode != SelectionMode.SESSION:
+            return
+
+        completion_list = self.query_one("#completion-list", FloatingList)
+        selected_item = completion_list.selected_item
+        if selected_item is None:
+            return
+
+        session_info = selected_item.value
+        session_path = Path(session_info.path)
+
+        current_session_path: Path | None = None
+        if self._runtime.session and self._runtime.session.session_file is not None:
+            current_session_path = Path(self._runtime.session.session_file)
+
+        if current_session_path is not None and session_path == current_session_path:
+            self.notify(
+                "Cannot delete current session", title="Sessions", timeout=2, severity="warning"
+            )
+            return
+
+        try:
+            session_path.unlink()
+        except FileNotFoundError:
+            pass
+        except Exception as exc:
+            self.notify(
+                f"Failed to delete session: {exc}", title="Sessions", timeout=3, severity="error"
+            )
+            return
+
+        items = self._build_resume_items()
+        was_at_bottom = self._is_chat_at_bottom()
+        if not items:
+            self._hide_completion_list()
+            input_box = self.query_one("#input-box", InputBox)
+            input_box.set_autocomplete_enabled(True)
+            input_box.set_completing(False)
+            self._selection_mode = None
+            self.notify(
+                "Session deleted (no saved sessions left)",
+                title="Sessions",
+                timeout=2,
+                severity="information",
+            )
+        else:
+            completion_list.update_items(items)
+            self.notify("Session deleted", title="Sessions", timeout=2, severity="information")
+
+        self._restore_chat_scroll_after_refresh(was_at_bottom)
+
+    def _handle_export_command(self) -> None:
+        from ..export import export_session_html
+
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if not self._runtime.session:
+            chat.add_info_message("No active session to export")
+            return
+
+        if not self._runtime.session.entries:
+            chat.add_info_message("Session has no messages to export")
+            return
+
+        try:
+            path = export_session_html(
+                cwd=self._cwd,
+                session_id=self._runtime.session.id,
+                output_dir=self._cwd,
+                version=getattr(self, "VERSION", ""),
+            )
+            chat.add_info_message(f"Session exported to {path.name}")
+        except Exception as e:
+            chat.add_info_message(f"Export failed: {e}", error=True)
+
+    def _handle_copy_command(self) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if not self._runtime.session:
+            chat.add_info_message("No agent messages to copy yet", error=True)
+            return
+
+        text = self._runtime.session.get_last_assistant_text()
+        if not text:
+            chat.add_info_message("No agent messages to copy yet", error=True)
+            return
+
+        copy_to_clipboard(text)
+        chat.show_status("Copied last agent message to clipboard")
+
+    def _handle_compact_command(self) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if self._is_running:
+            chat.add_info_message("Cannot compact while agent is running", error=True)
+            return
+
+        if self._runtime.provider is None or self._runtime.session is None:
+            chat.add_info_message("Agent not initialized", error=True)
+            return
+
+        if not self._runtime.session.all_messages:
+            chat.add_info_message("No conversation to compact", error=True)
+            return
+
+        chat.show_spinner_status("Compacting...")
+        self.run_worker(self._do_compact(), exclusive=False)
+
+    async def _do_compact(self) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        if self._runtime.provider is None or self._runtime.session is None:
+            chat.add_info_message("Agent not initialized", error=True)
+            return
+
+        try:
+            result = await self._runtime.compact_now()
+            chat.add_compaction_message(result.tokens_before)
+        except Exception as e:
+            chat.show_status("Compaction failed")
+            chat.add_info_message(f"Compaction failed: {e}", error=True)
+
+    def _format_session_label(self, message: str) -> str:
+        return " ".join(message.split())
+
+    def _format_session_age(self, modified: datetime) -> str:
+        now = datetime.now(UTC)
+        delta = max(0, int((now - modified).total_seconds()))
+        minutes = delta // 60
+        hours = delta // 3600
+        days = delta // 86400
+        weeks = days // 7
+
+        if minutes < 60:
+            value, unit = minutes, "m"
+        elif hours < 24:
+            value, unit = hours, "h"
+        elif days < 7:
+            value, unit = days, "d"
+        elif weeks < 52:
+            value, unit = weeks, "w"
+        else:
+            value, unit = weeks // 52, "y"
+
+        return f"{value:>2}{unit}"

vtx/ui/commands/settings.py

@@ -0,0 +1,286 @@
+"""/settings, /themes, /permissions, /thinking and /notifications commands."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from vtx import (
+    config,
+    set_colored_tool_badge,
+    set_git_context,
+    set_notifications_enabled,
+    set_permissions_mode,
+    set_show_welcome_shortcuts,
+    set_theme,
+    set_thinking_lines,
+)
+from vtx.config import (
+    NOTIFICATION_MODES,
+    PERMISSION_MODES,
+    THINKING_LINES_OPTIONS,
+    NotificationMode,
+    PermissionMode,
+    ThinkingLinesOption,
+)
+
+from ...themes import get_theme_options
+from ..chat import ChatLog
+from ..floating_list import FloatingList, ListItem
+from ..selection_mode import SelectionMode
+from ..widgets import InfoBar
+from .base import CommandSupport
+
+SettingsSelectionResult = Literal["reopened-picker", "closed"]
+
+
+class SettingsCommands(CommandSupport):
+    def _handle_themes_command(self, args: str) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+
+        requested = args.strip()
+        if requested:
+            try:
+                self._select_theme(requested)
+            except ValueError as e:
+                chat.add_info_message(str(e), error=True)
+            return
+
+        current_theme = config.ui.theme
+        items = [
+            ListItem(value=theme_id, label=f"{label} ✓" if theme_id == current_theme else label)
+            for theme_id, label in get_theme_options()
+        ]
+
+        self._show_selection_picker(items, SelectionMode.THEME)
+
+    def _select_theme(self, theme_id: str) -> None:
+        set_theme(theme_id)
+        self._apply_theme(theme_id)
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.add_info_message(
+            f"Theme changed to {theme_id}. Full theme refresh applies when vtx is restarted.",
+            warning=True,
+        )
+
+    def _handle_permissions_command(self, args: str) -> None:
+        descriptions: dict[PermissionMode, str] = {
+            "prompt": "ask before mutating tool calls",
+            "auto": "allow tool calls without approval prompts",
+        }
+        self._handle_choice_command(
+            args,
+            name="permission",
+            choices=PERMISSION_MODES,
+            current=config.permissions.mode,
+            descriptions=descriptions,
+            selection_mode=SelectionMode.PERMISSIONS,
+            select=self._select_permission_mode,
+        )
+
+    def _select_permission_mode(self, mode: PermissionMode) -> None:
+        set_permissions_mode(mode)
+        info_bar = self.query_one("#info-bar", InfoBar)
+        info_bar.set_permission_mode(mode)
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.show_status(f"Permission mode changed to {mode}")
+
+    def _handle_thinking_command(self, args: str) -> None:
+        chat = self.query_one("#chat-log", ChatLog)
+        if self._runtime.provider is None:
+            chat.add_info_message("Agent not initialized", error=True)
+            return
+
+        requested = args.strip()
+        if requested:
+            if requested in self._runtime.provider.thinking_levels:
+                self._select_thinking_level(requested)
+            else:
+                valid_levels = ", ".join(self._runtime.provider.thinking_levels)
+                chat.add_info_message(
+                    f"Invalid thinking level: {requested}. Use one of: {valid_levels}", error=True
+                )
+            return
+
+        items = [
+            ListItem(
+                value=level, label=f"{level} ✓" if level == self._runtime.thinking_level else level
+            )
+            for level in self._runtime.provider.thinking_levels
+        ]
+        self._show_selection_picker(items, SelectionMode.THINKING)
+
+    def _select_thinking_level(self, level: str) -> None:
+        if self._runtime.provider is None:
+            return
+
+        self._runtime.set_thinking_level(level)
+        self._sync_runtime_state()
+
+        info_bar = self.query_one("#info-bar", InfoBar)
+        info_bar.set_thinking_level(level)
+        self._apply_thinking_level_style(level)
+
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.show_status(f"Thinking level changed to {level}")
+
+    def _show_thinking_lines_picker(self) -> None:
+        descriptions: dict[ThinkingLinesOption, str] = {
+            "1": "show 1 line",
+            "2": "show 2 lines",
+            "3": "show 3 lines",
+            "4": "show 4 lines",
+            "5": "show 5 lines",
+            "none": "no truncation",
+        }
+        items = self._build_choice_items(
+            THINKING_LINES_OPTIONS, config.ui.thinking_lines, descriptions
+        )
+        self._show_selection_picker(items, SelectionMode.THINKING_LINES)
+
+    def _select_thinking_lines(self, lines: ThinkingLinesOption) -> None:
+        set_thinking_lines(lines)
+        chat = self.query_one("#chat-log", ChatLog)
+        label = (
+            "no truncation" if lines == "none" else f"{lines} line{'s' if lines != '1' else ''}"
+        )
+        chat.show_status(f"Thinking lines changed to {label}")
+
+    def _handle_notifications_command(self, args: str) -> None:
+        current: NotificationMode = "on" if config.notifications.enabled else "off"
+        descriptions: dict[NotificationMode, str] = {
+            "on": "play notification sounds",
+            "off": "disable notification sounds",
+        }
+        self._handle_choice_command(
+            args,
+            name="notifications",
+            choices=NOTIFICATION_MODES,
+            current=current,
+            descriptions=descriptions,
+            selection_mode=SelectionMode.NOTIFICATIONS,
+            select=self._select_notifications_mode,
+        )
+
+    def _select_notifications_mode(self, mode: NotificationMode) -> None:
+        set_notifications_enabled(mode == "on")
+        chat = self.query_one("#chat-log", ChatLog)
+        chat.show_status(f"Notifications turned {mode}")
+
+    # -------------------------------------------------------------------------
+    # Settings (unified panel for themes, permissions, notifications, thinking)
+    # -------------------------------------------------------------------------
+
+    def _build_settings_items(self) -> list[ListItem[str]]:
+        notification_status = "on" if config.notifications.enabled else "off"
+        try:
+            thinking_level = self._runtime.thinking_level or "off"
+        except Exception:
+            thinking_level = "off"
+
+        shortcut_status = "on" if config.ui.show_welcome_shortcuts else "off"
+        thinking_lines_status = config.ui.thinking_lines
+        colored_badge_status = "on" if config.ui.colored_tool_badge else "off"
+        git_context_status = "on" if config.llm.system_prompt.git_context else "off"
+        return [
+            ListItem(
+                value="colored-tool-badge",
+                label="colored-tool-badge",
+                description=colored_badge_status,
+            ),
+            ListItem(value="git-context", label="git-context", description=git_context_status),
+            ListItem(
+                value="notifications", label="notifications", description=notification_status
+            ),
+            ListItem(value="show-shortcuts", label="show-shortcuts", description=shortcut_status),
+            ListItem(
+                value="permissions", label="permissions", description=config.permissions.mode
+            ),
+            ListItem(value="themes", label="themes", description=config.ui.theme),
+            ListItem(value="thinking", label="thinking", description=thinking_level),
+            ListItem(
+                value="thinking-lines", label="thinking-lines", description=thinking_lines_status
+            ),
+        ]
+
+    def _show_settings_picker(self, selected_value: str | None = None) -> None:
+        items = self._build_settings_items()
+        self._show_selection_picker(items, SelectionMode.SETTINGS, max_label_width=40)
+        self._settings_selected_value = selected_value
+        if selected_value is not None:
+            completion_list = self.query_one("#completion-list", FloatingList)
+            completion_list.select_value(selected_value)
+
+    def _handle_settings_command(self) -> None:
+        self._show_settings_picker()
+
+    def _handle_settings_select(self, item_value: str) -> SettingsSelectionResult:
+        if item_value == "notifications":
+            current_enabled = config.notifications.enabled
+            set_notifications_enabled(not current_enabled)
+            mode: NotificationMode = "on" if not current_enabled else "off"
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.show_status(f"Notifications turned {mode}")
+            self._show_settings_picker(selected_value=item_value)
+            return "reopened-picker"
+
+        elif item_value == "show-shortcuts":
+            shortcuts_current = config.ui.show_welcome_shortcuts
+            set_show_welcome_shortcuts(not shortcuts_current)
+            mode = "on" if not shortcuts_current else "off"
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.show_status(f"Welcome shortcuts turned {mode}")
+            self._show_settings_picker(selected_value=item_value)
+            return "reopened-picker"
+
+        elif item_value == "permissions":
+            current: PermissionMode = config.permissions.mode
+            new_mode: PermissionMode = "auto" if current == "prompt" else "prompt"
+            set_permissions_mode(new_mode)
+            info_bar = self.query_one("#info-bar", InfoBar)
+            info_bar.set_permission_mode(new_mode)
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.show_status(f"Permission mode changed to {new_mode}")
+            self._show_settings_picker(selected_value=item_value)
+            return "reopened-picker"
+
+        elif item_value == "themes":
+            self._settings_active = True
+            self._handle_themes_command("")
+            return "reopened-picker"
+
+        elif item_value == "thinking":
+            if self._runtime.provider is None:
+                self._handle_thinking_command("")
+                return "closed"
+            self._settings_active = True
+            self._handle_thinking_command("")
+            return "reopened-picker"
+
+        elif item_value == "thinking-lines":
+            self._settings_active = True
+            self._show_thinking_lines_picker()
+            return "reopened-picker"
+
+        elif item_value == "colored-tool-badge":
+            badge_current = config.ui.colored_tool_badge
+            set_colored_tool_badge(not badge_current)
+            mode = "on" if not badge_current else "off"
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.show_status(f"Colored tool badge turned {mode}")
+            self._show_settings_picker(selected_value=item_value)
+            return "reopened-picker"
+
+        elif item_value == "git-context":
+            git_current = config.llm.system_prompt.git_context
+            set_git_context(not git_current)
+            mode = "on" if not git_current else "off"
+            chat = self.query_one("#chat-log", ChatLog)
+            chat.show_status(f"Git context turned {mode}")
+            chat.add_info_message(
+                "Git context change applies on new conversations (use /new) or on vtx restart.",
+                warning=True,
+            )
+            self._show_settings_picker(selected_value=item_value)
+            return "reopened-picker"
+
+        return "closed"