code-puppy 0.0.97__py3-none-any.whl → 0.0.118__py3-none-any.whl

code_puppy/tui/components/sidebar.py

@@ -0,0 +1,309 @@
+"""
+Sidebar component with history tab.
+"""
+
+import time
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.events import Key
+from textual.widgets import Label, ListItem, ListView, TabbedContent, TabPane
+
+from ..components.command_history_modal import CommandHistoryModal
+
+# Import the shared message class and history reader
+from ..models.command_history import HistoryFileReader
+
+
+class Sidebar(Container):
+    """Sidebar with session history."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # Double-click detection variables
+        self._last_click_time = 0
+        self._last_clicked_item = None
+        self._double_click_threshold = 0.5  # 500ms for double-click
+
+        # Initialize history reader
+        self.history_reader = HistoryFileReader()
+
+        # Current index for history navigation - centralized reference
+        self.current_history_index = 0
+        self.history_entries = []
+
+    DEFAULT_CSS = """
+    Sidebar {
+        dock: left;
+        width: 30;
+        min-width: 20;
+        max-width: 50;
+        background: $surface;
+        border-right: solid $primary;
+        display: none;
+    }
+
+    #sidebar-tabs {
+        height: 1fr;
+    }
+
+    #history-list {
+        height: 1fr;
+    }
+
+    .history-interactive {
+        color: #34d399;
+    }
+
+    .history-tui {
+        color: #60a5fa;
+    }
+
+    .history-system {
+        color: #fbbf24;
+        text-style: italic;
+    }
+
+    .history-command {
+        /* Use default text color from theme */
+    }
+
+    .history-generic {
+        color: #d1d5db;
+    }
+
+    .history-empty {
+        color: #6b7280;
+        text-style: italic;
+    }
+
+    .history-error {
+        color: #ef4444;
+    }
+
+    .file-item {
+        color: #d1d5db;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        """Create the sidebar layout with tabs."""
+        with TabbedContent(id="sidebar-tabs"):
+            with TabPane("📜 History", id="history-tab"):
+                yield ListView(id="history-list")
+
+    def on_mount(self) -> None:
+        """Initialize the sidebar when mounted."""
+        # Set up event handlers for keyboard interaction
+        history_list = self.query_one("#history-list", ListView)
+
+        # Add a class to make it focusable
+        history_list.can_focus = True
+
+        # Load command history
+        self.load_command_history()
+
+    @on(ListView.Highlighted)
+    def on_list_highlighted(self, event: ListView.Highlighted) -> None:
+        """Handle highlighting of list items to ensure they can be selected."""
+        # This ensures the item gets focus when highlighted by arrow keys
+        if event.list_view.id == "history-list":
+            event.list_view.focus()
+            # Sync the current_history_index with the ListView index to fix modal sync issue
+            self.current_history_index = event.list_view.index
+
+    @on(ListView.Selected)
+    def on_list_selected(self, event: ListView.Selected) -> None:
+        """Handle selection of list items (including mouse clicks).
+
+        Implements double-click detection to allow users to retrieve history items
+        by either pressing ENTER or double-clicking with the mouse.
+        """
+        if event.list_view.id == "history-list":
+            current_time = time.time()
+            selected_item = event.item
+
+            # Check if this is a double-click
+            if (
+                selected_item == self._last_clicked_item
+                and current_time - self._last_click_time <= self._double_click_threshold
+                and hasattr(selected_item, "command_entry")
+            ):
+                # Double-click detected! Show command in modal
+                # Find the index of this item
+                history_list = self.query_one("#history-list", ListView)
+                self.current_history_index = history_list.index
+
+                # Push the modal screen - it will get data from the sidebar
+                self.app.push_screen(CommandHistoryModal())
+
+                # Reset click tracking to prevent triple-click issues
+                self._last_click_time = 0
+                self._last_clicked_item = None
+            else:
+                # Single click - just update tracking
+                self._last_click_time = current_time
+                self._last_clicked_item = selected_item
+
+    @on(Key)
+    def on_key(self, event: Key) -> None:
+        """Handle key events for the sidebar."""
+        # Handle Enter key on the history list
+        if event.key == "enter":
+            history_list = self.query_one("#history-list", ListView)
+            if (
+                history_list.has_focus
+                and history_list.highlighted_child
+                and hasattr(history_list.highlighted_child, "command_entry")
+            ):
+                # Show command details in modal
+                # Update the current history index to match this item
+                self.current_history_index = history_list.index
+
+                # Push the modal screen - it will get data from the sidebar
+                self.app.push_screen(CommandHistoryModal())
+
+                # Stop propagation
+                event.stop()
+                event.prevent_default()
+
+    def load_command_history(self) -> None:
+        """Load command history from file into the history list."""
+        try:
+            # Clear existing items
+            history_list = self.query_one("#history-list", ListView)
+            history_list.clear()
+
+            # Get command history entries (limit to last 50)
+            entries = self.history_reader.read_history(max_entries=50)
+
+            # Filter out CLI-specific commands that aren't relevant for TUI
+            cli_commands = {
+                "/help",
+                "/exit",
+                "/m",
+                "/motd",
+                "/show",
+                "/set",
+                "/tools",
+            }
+            filtered_entries = []
+            for entry in entries:
+                command = entry.get("command", "").strip()
+                # Skip CLI commands but keep everything else
+                if not any(command.startswith(cli_cmd) for cli_cmd in cli_commands):
+                    filtered_entries.append(entry)
+
+            # Store filtered entries centrally
+            self.history_entries = filtered_entries
+
+            # Reset history index
+            self.current_history_index = 0
+
+            if not filtered_entries:
+                # No history available (after filtering)
+                history_list.append(
+                    ListItem(Label("No command history", classes="history-empty"))
+                )
+                return
+
+            # Add filtered entries to the list (most recent first)
+            for entry in filtered_entries:
+                timestamp = entry["timestamp"]
+                command = entry["command"]
+
+                # Format timestamp for display
+                time_display = self.history_reader.format_timestamp(timestamp)
+
+                # Truncate command for display if needed
+                display_text = command
+                if len(display_text) > 60:
+                    display_text = display_text[:57] + "..."
+
+                # Create list item
+                label = Label(
+                    f"[{time_display}] {display_text}", classes="history-command"
+                )
+                list_item = ListItem(label)
+                list_item.command_entry = entry
+                history_list.append(list_item)
+
+            # Focus on the most recent command (first in the list)
+            if len(history_list.children) > 0:
+                history_list.index = 0
+                # Sync the current_history_index to match the ListView index
+                self.current_history_index = 0
+
+                # Note: We don't automatically show the modal here when just loading the history
+                # That will be handled by the app's action_toggle_sidebar method
+                # This ensures the modal only appears when explicitly opening the sidebar, not during refresh
+
+        except Exception as e:
+            # Add error item
+            history_list = self.query_one("#history-list", ListView)
+            history_list.clear()
+            history_list.append(
+                ListItem(
+                    Label(f"Error loading history: {str(e)}", classes="history-error")
+                )
+            )
+
+    def navigate_to_next_command(self) -> bool:
+        """Navigate to the next command in history.
+
+        Returns:
+            bool: True if navigation succeeded, False otherwise
+        """
+        if (
+            not self.history_entries
+            or self.current_history_index >= len(self.history_entries) - 1
+        ):
+            return False
+
+        # Increment the index
+        self.current_history_index += 1
+
+        # Update the listview selection
+        try:
+            history_list = self.query_one("#history-list", ListView)
+            if history_list and self.current_history_index < len(history_list.children):
+                history_list.index = self.current_history_index
+        except Exception:
+            pass
+
+        return True
+
+    def navigate_to_previous_command(self) -> bool:
+        """Navigate to the previous command in history.
+
+        Returns:
+            bool: True if navigation succeeded, False otherwise
+        """
+        if not self.history_entries or self.current_history_index <= 0:
+            return False
+
+        # Decrement the index
+        self.current_history_index -= 1
+
+        # Update the listview selection
+        try:
+            history_list = self.query_one("#history-list", ListView)
+            if history_list and self.current_history_index >= 0:
+                history_list.index = self.current_history_index
+        except Exception:
+            pass
+
+        return True
+
+    def get_current_command_entry(self) -> dict:
+        """Get the current command entry based on the current index.
+
+        Returns:
+            dict: The current command entry or empty dict if not available
+        """
+        if self.history_entries and 0 <= self.current_history_index < len(
+            self.history_entries
+        ):
+            return self.history_entries[self.current_history_index]
+        return {"command": "", "timestamp": ""}

code_puppy/tui/components/status_bar.py

@@ -0,0 +1,182 @@
+"""
+Status bar component for the TUI.
+"""
+
+import os
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widgets import Static
+
+
+class StatusBar(Static):
+    """Status bar showing current model, puppy name, and connection status."""
+
+    DEFAULT_CSS = """
+    StatusBar {
+        dock: top;
+        height: 1;
+        background: $primary;
+        color: $text;
+        text-align: right;
+        padding: 0 1;
+    }
+
+    #status-content {
+        text-align: right;
+        width: 100%;
+    }
+    """
+
+    current_model = reactive("")
+    puppy_name = reactive("")
+    connection_status = reactive("Connected")
+    agent_status = reactive("Ready")
+    progress_visible = reactive(False)
+    token_count = reactive(0)
+    token_capacity = reactive(0)
+    token_proportion = reactive(0.0)
+
+    def compose(self) -> ComposeResult:
+        yield Static(id="status-content")
+
+    def watch_current_model(self) -> None:
+        self.update_status()
+
+    def watch_puppy_name(self) -> None:
+        self.update_status()
+
+    def watch_connection_status(self) -> None:
+        self.update_status()
+
+    def watch_agent_status(self) -> None:
+        self.update_status()
+
+    def watch_token_count(self) -> None:
+        self.update_status()
+
+    def watch_token_capacity(self) -> None:
+        self.update_status()
+
+    def watch_token_proportion(self) -> None:
+        self.update_status()
+
+    def watch_progress_visible(self) -> None:
+        self.update_status()
+
+    def update_status(self) -> None:
+        """Update the status bar content with responsive design."""
+        status_widget = self.query_one("#status-content", Static)
+
+        # Get current working directory
+        cwd = os.getcwd()
+        cwd_short = os.path.basename(cwd) if cwd != "/" else "/"
+
+        # Add agent status indicator with different colors
+        if self.agent_status == "Thinking":
+            status_indicator = "🤔"
+            status_color = "yellow"
+        elif self.agent_status == "Processing":
+            status_indicator = "⚡"
+            status_color = "blue"
+        elif self.agent_status == "Busy":
+            status_indicator = "🔄"
+            status_color = "orange"
+        else:  # Ready
+            status_indicator = "✅"
+            status_color = "green"
+
+        # Get terminal width for responsive content
+        try:
+            terminal_width = self.app.size.width if hasattr(self.app, "size") else 80
+        except Exception:
+            terminal_width = 80
+
+        # Create responsive status text based on terminal width
+        rich_text = Text()
+
+        # Token status with color coding
+        token_status = ""
+        token_color = "green"
+        if self.token_count > 0 and self.token_capacity > 0:
+            # Import here to avoid circular import
+            from code_puppy.config import get_summarization_threshold
+
+            summarization_threshold = get_summarization_threshold()
+
+            if self.token_proportion > summarization_threshold:
+                token_color = "red"
+                token_status = f"🔴 {self.token_count}/{self.token_capacity} ({self.token_proportion:.1%})"
+            elif self.token_proportion > (
+                summarization_threshold - 0.15
+            ):  # 15% before summarization threshold
+                token_color = "yellow"
+                token_status = f"🟡 {self.token_count}/{self.token_capacity} ({self.token_proportion:.1%})"
+            else:
+                token_color = "green"
+                token_status = f"🟢 {self.token_count}/{self.token_capacity} ({self.token_proportion:.1%})"
+
+        if terminal_width >= 140:
+            # Extra wide - show full path and all info including tokens
+            rich_text.append(
+                f"📁 {cwd} | 🐶 {self.puppy_name} | Model: {self.current_model} | "
+            )
+            if token_status:
+                rich_text.append(f"{token_status} | ", style=token_color)
+            rich_text.append(
+                f"{status_indicator} {self.agent_status}", style=status_color
+            )
+        elif terminal_width >= 100:
+            # Full status display for wide terminals
+            rich_text.append(
+                f"📁 {cwd_short} | 🐶 {self.puppy_name} | Model: {self.current_model} | "
+            )
+            rich_text.append(
+                f"{status_indicator} {self.agent_status}", style=status_color
+            )
+        elif terminal_width >= 120:
+            # Medium display - shorten model name if needed
+            model_display = (
+                self.current_model[:15] + "..."
+                if len(self.current_model) > 18
+                else self.current_model
+            )
+            rich_text.append(
+                f"📁 {cwd_short} | 🐶 {self.puppy_name} | {model_display} | "
+            )
+            if token_status:
+                rich_text.append(f"{token_status} | ", style=token_color)
+            rich_text.append(
+                f"{status_indicator} {self.agent_status}", style=status_color
+            )
+        elif terminal_width >= 60:
+            # Compact display - use abbreviations
+            puppy_short = (
+                self.puppy_name[:8] + "..."
+                if len(self.puppy_name) > 10
+                else self.puppy_name
+            )
+            model_short = (
+                self.current_model[:12] + "..."
+                if len(self.current_model) > 15
+                else self.current_model
+            )
+            rich_text.append(f"📁 {cwd_short} | 🐶 {puppy_short} | {model_short} | ")
+            rich_text.append(f"{status_indicator}", style=status_color)
+        else:
+            # Minimal display for very narrow terminals
+            cwd_mini = cwd_short[:8] + "..." if len(cwd_short) > 10 else cwd_short
+            rich_text.append(f"📁 {cwd_mini} | ")
+            rich_text.append(f"{status_indicator}", style=status_color)
+
+        rich_text.justify = "right"
+        status_widget.update(rich_text)
+
+    def update_token_info(
+        self, current_tokens: int, max_tokens: int, proportion: float
+    ) -> None:
+        """Update token information in the status bar."""
+        self.token_count = current_tokens
+        self.token_capacity = max_tokens
+        self.token_proportion = proportion

code_puppy/tui/messages.py

@@ -0,0 +1,27 @@
+"""
+Custom message classes for TUI components.
+"""
+
+from textual.message import Message
+
+
+class HistoryEntrySelected(Message):
+    """Message sent when a history entry is selected from the sidebar."""
+
+    def __init__(self, history_entry: dict) -> None:
+        """Initialize with the history entry data."""
+        self.history_entry = history_entry
+        super().__init__()
+
+
+class CommandSelected(Message):
+    """Message sent when a command is selected from the history modal."""
+
+    def __init__(self, command: str) -> None:
+        """Initialize with the command text.
+
+        Args:
+            command: The command text that was selected
+        """
+        self.command = command
+        super().__init__()

code_puppy/tui/models/__init__.py

@@ -0,0 +1,8 @@
+"""
+TUI models package.
+"""
+
+from .chat_message import ChatMessage
+from .enums import MessageType
+
+__all__ = ["MessageType", "ChatMessage"]

code_puppy/tui/models/chat_message.py

@@ -0,0 +1,25 @@
+"""
+Chat message data model.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict
+
+from .enums import MessageType
+
+
+@dataclass
+class ChatMessage:
+    """Represents a message in the chat interface."""
+
+    id: str
+    type: MessageType
+    content: str
+    timestamp: datetime
+    metadata: Dict[str, Any] = None
+    group_id: str = None
+
+    def __post_init__(self):
+        if self.metadata is None:
+            self.metadata = {}

code_puppy/tui/models/command_history.py

@@ -0,0 +1,89 @@
+"""
+Command history reader for TUI history tab.
+"""
+
+import os
+import re
+from datetime import datetime
+from typing import Dict, List
+
+from code_puppy.config import COMMAND_HISTORY_FILE
+
+
+class HistoryFileReader:
+    """Reads and parses the command history file for display in the TUI history tab."""
+
+    def __init__(self, history_file_path: str = COMMAND_HISTORY_FILE):
+        """Initialize the history file reader.
+
+        Args:
+            history_file_path: Path to the command history file. Defaults to the standard location.
+        """
+        self.history_file_path = history_file_path
+        self._timestamp_pattern = re.compile(
+            r"^# (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})"
+        )
+
+    def read_history(self, max_entries: int = 100) -> List[Dict[str, str]]:
+        """Read command history from the history file.
+
+        Args:
+            max_entries: Maximum number of entries to read. Defaults to 100.
+
+        Returns:
+            List of history entries with timestamp and command, most recent first.
+        """
+        if not os.path.exists(self.history_file_path):
+            return []
+
+        try:
+            with open(self.history_file_path, "r") as f:
+                content = f.read()
+
+            # Split content by timestamp marker
+            raw_chunks = re.split(r"(# \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})", content)
+
+            # Filter out empty chunks
+            chunks = [chunk for chunk in raw_chunks if chunk.strip()]
+
+            entries = []
+
+            # Process chunks in pairs (timestamp and command)
+            i = 0
+            while i < len(chunks) - 1:
+                if self._timestamp_pattern.match(chunks[i]):
+                    timestamp = self._timestamp_pattern.match(chunks[i]).group(1)
+                    command_text = chunks[i + 1].strip()
+
+                    if command_text:  # Skip empty commands
+                        entries.append(
+                            {"timestamp": timestamp, "command": command_text}
+                        )
+
+                    i += 2
+                else:
+                    # Skip invalid chunks
+                    i += 1
+
+            # Limit the number of entries and reverse to get most recent first
+            return entries[-max_entries:][::-1]
+
+        except Exception:
+            # Return empty list on any error
+            return []
+
+    def format_timestamp(self, timestamp: str, format_str: str = "%H:%M:%S") -> str:
+        """Format a timestamp string for display.
+
+        Args:
+            timestamp: ISO format timestamp string (YYYY-MM-DDThh:mm:ss)
+            format_str: Format string for datetime.strftime
+
+        Returns:
+            Formatted timestamp string
+        """
+        try:
+            dt = datetime.fromisoformat(timestamp)
+            return dt.strftime(format_str)
+        except (ValueError, TypeError):
+            return timestamp

code_puppy/tui/models/enums.py

@@ -0,0 +1,24 @@
+"""
+Enums for the TUI module.
+"""
+
+from enum import Enum
+
+
+class MessageType(Enum):
+    """Types of messages in the chat interface."""
+
+    USER = "user"
+    AGENT = "agent"
+    SYSTEM = "system"
+    ERROR = "error"
+    DIVIDER = "divider"
+    INFO = "info"
+    SUCCESS = "success"
+    WARNING = "warning"
+    TOOL_OUTPUT = "tool_output"
+    COMMAND_OUTPUT = "command_output"
+
+    AGENT_REASONING = "agent_reasoning"
+    PLANNED_NEXT_STEPS = "planned_next_steps"
+    AGENT_RESPONSE = "agent_response"

code_puppy/tui/screens/__init__.py

@@ -0,0 +1,13 @@
+"""
+TUI screens package.
+"""
+
+from .help import HelpScreen
+from .settings import SettingsScreen
+from .tools import ToolsScreen
+
+__all__ = [
+    "HelpScreen",
+    "SettingsScreen",
+    "ToolsScreen",
+]