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

code_puppy/tui/components/command_history_modal.py

@@ -0,0 +1,218 @@
+"""
+Modal component for displaying command history entries.
+"""
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.events import Key
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from ..messages import CommandSelected
+
+
+class CommandHistoryModal(ModalScreen):
+    """Modal for displaying a command history entry."""
+
+    def __init__(self, **kwargs):
+        """Initialize the modal with command history data.
+
+        Args:
+            **kwargs: Additional arguments to pass to the parent class
+        """
+        super().__init__(**kwargs)
+
+        # Get the current command from the sidebar
+        try:
+            # We'll get everything from the sidebar on demand
+            self.sidebar = None
+            self.command = ""
+            self.timestamp = ""
+        except Exception:
+            self.command = ""
+            self.timestamp = ""
+
+        # UI components to update
+        self.command_display = None
+        self.timestamp_display = None
+
+    def on_mount(self) -> None:
+        """Setup when the modal is mounted."""
+        # Get the sidebar and current command entry
+        try:
+            self.sidebar = self.app.query_one("Sidebar")
+            current_entry = self.sidebar.get_current_command_entry()
+            self.command = current_entry["command"]
+            self.timestamp = current_entry["timestamp"]
+            self.update_display()
+        except Exception as e:
+            import logging
+
+            logging.debug(f"Error initializing modal: {str(e)}")
+
+    DEFAULT_CSS = """
+    CommandHistoryModal {
+        align: center middle;
+    }
+
+    #modal-container {
+        width: 80%;
+        max-width: 100;
+        /* Set a definite height that's large enough but fits on screen */
+        height: 22;  /* Increased height to make room for navigation hint */
+        min-height: 18;
+        background: $surface;
+        border: solid $primary;
+        /* Increase vertical padding to add more space between elements */
+        padding: 1 2;
+        /* Use vertical layout to ensure proper element sizing */
+        layout: vertical;
+    }
+
+    #timestamp-display {
+        width: 100%;
+        margin-bottom: 1;
+        color: $text-muted;
+        text-align: right;
+        /* Fix the height */
+        height: 1;
+        margin-top: 0;
+    }
+
+    #command-display {
+        width: 100%;
+        /* Allow this container to grow/shrink as needed but keep buttons visible */
+        min-height: 3;
+        height: 1fr;
+        max-height: 12;
+        padding: 0 1;
+        margin-bottom: 1;
+        margin-top: 1;
+        background: $surface-darken-1;
+        border: solid $primary-darken-2;
+        overflow: auto;
+    }
+
+    #nav-hint {
+        width: 100%;
+        color: $text;
+        text-align: center;
+        margin: 1 0;
+    }
+
+    .button-container {
+        width: 100%;
+        /* Fix the height to ensure buttons are always visible */
+        height: 3;
+        align-horizontal: right;
+        margin-top: 1;
+    }
+
+    Button {
+        margin-right: 1;
+    }
+
+    #use-button {
+        background: $success;
+    }
+
+    #cancel-button {
+        background: $primary-darken-1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        """Create the modal layout."""
+        with Container(id="modal-container"):
+            # Header with timestamp
+            self.timestamp_display = Label(
+                f"Timestamp: {self.timestamp}", id="timestamp-display"
+            )
+            yield self.timestamp_display
+
+            # Scrollable content area that can expand/contract as needed
+            # The content will scroll if it's too long, ensuring buttons remain visible
+            with Container(id="command-display"):
+                self.command_display = Static(self.command)
+                yield self.command_display
+
+            # Super simple navigation hint
+            yield Label("Press Up/Down arrows to navigate history", id="nav-hint")
+
+            # Fixed button container at the bottom
+            with Horizontal(classes="button-container"):
+                yield Button("Cancel", id="cancel-button", variant="default")
+                yield Button("Use Command", id="use-button", variant="primary")
+
+    def on_key(self, event: Key) -> None:
+        """Handle key events for navigation."""
+        # Handle arrow keys for navigation
+        if event.key == "down":
+            self.navigate_to_next_command()
+            event.prevent_default()
+        elif event.key == "up":
+            self.navigate_to_previous_command()
+            event.prevent_default()
+        elif event.key == "escape":
+            self.app.pop_screen()
+            event.prevent_default()
+
+    def navigate_to_next_command(self) -> None:
+        """Navigate to the next command in history."""
+        try:
+            # Get the sidebar
+            if not self.sidebar:
+                self.sidebar = self.app.query_one("Sidebar")
+
+            # Use sidebar's method to navigate
+            if self.sidebar.navigate_to_next_command():
+                # Get updated command entry
+                current_entry = self.sidebar.get_current_command_entry()
+                self.command = current_entry["command"]
+                self.timestamp = current_entry["timestamp"]
+                self.update_display()
+        except Exception as e:
+            # Log the error but don't crash
+            import logging
+
+            logging.debug(f"Error navigating to next command: {str(e)}")
+
+    def navigate_to_previous_command(self) -> None:
+        """Navigate to the previous command in history."""
+        try:
+            # Get the sidebar
+            if not self.sidebar:
+                self.sidebar = self.app.query_one("Sidebar")
+
+            # Use sidebar's method to navigate
+            if self.sidebar.navigate_to_previous_command():
+                # Get updated command entry
+                current_entry = self.sidebar.get_current_command_entry()
+                self.command = current_entry["command"]
+                self.timestamp = current_entry["timestamp"]
+                self.update_display()
+        except Exception as e:
+            # Log the error but don't crash
+            import logging
+
+            logging.debug(f"Error navigating to previous command: {str(e)}")
+
+    def update_display(self) -> None:
+        """Update the display with the current command and timestamp."""
+        if self.command_display:
+            self.command_display.update(self.command)
+        if self.timestamp_display:
+            self.timestamp_display.update(f"Timestamp: {self.timestamp}")
+
+    @on(Button.Pressed, "#use-button")
+    def use_command(self) -> None:
+        """Handle use button press."""
+        # Post a message to the app with the selected command
+        self.post_message(CommandSelected(self.command))
+        self.app.pop_screen()
+
+    @on(Button.Pressed, "#cancel-button")
+    def cancel(self) -> None:
+        """Handle cancel button press."""
+        self.app.pop_screen()

code_puppy/tui/components/copy_button.py

@@ -0,0 +1,139 @@
+"""
+Copy button component for copying agent responses to clipboard.
+"""
+
+import subprocess
+import sys
+from typing import Optional
+
+from textual.binding import Binding
+from textual.events import Click
+from textual.message import Message
+from textual.widgets import Button
+
+
+class CopyButton(Button):
+    """A button that copies associated text to the clipboard."""
+
+    DEFAULT_CSS = """
+    CopyButton {
+        width: auto;
+        height: 3;
+        min-width: 8;
+        margin: 0 1 1 1;
+        padding: 0 1;
+        background: $primary;
+        color: $text;
+        border: none;
+        text-align: center;
+    }
+
+    CopyButton:hover {
+        background: $accent;
+        color: $text;
+    }
+
+    CopyButton:focus {
+        background: $accent;
+        color: $text;
+        text-style: bold;
+    }
+
+    CopyButton.-pressed {
+        background: $success;
+        color: $text;
+    }
+    """
+
+    BINDINGS = [
+        Binding("enter", "press", "Copy", show=False),
+        Binding("space", "press", "Copy", show=False),
+    ]
+
+    def __init__(self, text_to_copy: str, **kwargs):
+        super().__init__("📋 Copy", **kwargs)
+        self.text_to_copy = text_to_copy
+        self._original_label = "📋 Copy"
+        self._copied_label = "✅ Copied!"
+
+    class CopyCompleted(Message):
+        """Message sent when text is successfully copied."""
+
+        def __init__(self, success: bool, error: Optional[str] = None):
+            super().__init__()
+            self.success = success
+            self.error = error
+
+    def copy_to_clipboard(self, text: str) -> tuple[bool, Optional[str]]:
+        """
+        Copy text to clipboard using platform-appropriate method.
+
+        Returns:
+            tuple: (success: bool, error_message: Optional[str])
+        """
+        try:
+            if sys.platform == "darwin":  # macOS
+                subprocess.run(
+                    ["pbcopy"], input=text, text=True, check=True, capture_output=True
+                )
+            elif sys.platform == "win32":  # Windows
+                subprocess.run(
+                    ["clip"], input=text, text=True, check=True, capture_output=True
+                )
+            else:  # Linux and other Unix-like systems
+                # Try xclip first, then xsel as fallback
+                try:
+                    subprocess.run(
+                        ["xclip", "-selection", "clipboard"],
+                        input=text,
+                        text=True,
+                        check=True,
+                        capture_output=True,
+                    )
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    # Fallback to xsel
+                    subprocess.run(
+                        ["xsel", "--clipboard", "--input"],
+                        input=text,
+                        text=True,
+                        check=True,
+                        capture_output=True,
+                    )
+
+            return True, None
+
+        except subprocess.CalledProcessError as e:
+            return False, f"Clipboard command failed: {e}"
+        except FileNotFoundError:
+            if sys.platform not in ["darwin", "win32"]:
+                return (
+                    False,
+                    "Clipboard utilities not found. Please install xclip or xsel.",
+                )
+            else:
+                return False, "System clipboard command not found."
+        except Exception as e:
+            return False, f"Unexpected error: {e}"
+
+    def on_click(self, event: Click) -> None:
+        """Handle button click to copy text."""
+        self.action_press()
+
+    def action_press(self) -> None:
+        """Copy the text to clipboard and provide visual feedback."""
+        success, error = self.copy_to_clipboard(self.text_to_copy)
+
+        if success:
+            # Visual feedback - change button text temporarily
+            self.label = self._copied_label
+            self.add_class("-pressed")
+
+            # Reset button appearance after a short delay
+            # self.set_timer(1.5, self._reset_button_appearance)
+
+        # Send message about copy operation
+        self.post_message(self.CopyCompleted(success, error))
+
+    def update_text_to_copy(self, new_text: str) -> None:
+        """Update the text that will be copied when button is pressed."""
+        self.text_to_copy = new_text

code_puppy/tui/components/custom_widgets.py

@@ -0,0 +1,58 @@
+"""
+Custom widget components for the TUI.
+"""
+
+from textual.binding import Binding
+from textual.events import Key
+from textual.message import Message
+from textual.widgets import TextArea
+
+
+class CustomTextArea(TextArea):
+    """Custom TextArea that sends a message with Enter and allows new lines with Shift+Enter."""
+
+    # Define key bindings
+    BINDINGS = [
+        Binding("alt+enter", "insert_newline", ""),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def on_key(self, event):
+        """Handle key events before they reach the internal _on_key handler."""
+        # Explicitly handle escape+enter/alt+enter sequences
+        if event.key == "escape+enter" or event.key == "alt+enter":
+            self.action_insert_newline()
+            event.prevent_default()
+            event.stop()
+            return
+
+    def _on_key(self, event: Key) -> None:
+        """Override internal key handler to intercept Enter keys."""
+        # Handle Enter key specifically
+        if event.key == "enter":
+            # Check if this key is part of an escape sequence (Alt+Enter)
+            if hasattr(event, "is_cursor_sequence") or (
+                hasattr(event, "meta") and event.meta
+            ):
+                # If it's part of an escape sequence, let the parent handle it
+                # so that bindings can process it
+                super()._on_key(event)
+                return
+
+            # This handles plain Enter only, not escape+enter
+            self.post_message(self.MessageSent())
+            return  # Don't call super() to prevent default newline behavior
+
+        # Let TextArea handle other keys
+        super()._on_key(event)
+
+    def action_insert_newline(self) -> None:
+        """Action to insert a new line - called by shift+enter and escape+enter bindings."""
+        self.insert("\n")
+
+    class MessageSent(Message):
+        """Message sent when Enter key is pressed (without Shift)."""
+
+        pass

code_puppy/tui/components/input_area.py

@@ -0,0 +1,167 @@
+"""
+Input area component for message input.
+"""
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widgets import Button, Static
+
+from code_puppy.messaging.spinner import TextualSpinner
+
+from .custom_widgets import CustomTextArea
+
+# Alias SimpleSpinnerWidget to TextualSpinner for backward compatibility
+SimpleSpinnerWidget = TextualSpinner
+
+
+class SubmitCancelButton(Button):
+    """A button that toggles between submit and cancel states."""
+
+    is_cancel_mode = reactive(False)
+
+    DEFAULT_CSS = """
+    SubmitCancelButton {
+        width: 3;
+        min-width: 3;
+        height: 3;
+        content-align: center middle;
+        border: none;
+        background: $surface;
+    }
+
+    SubmitCancelButton:focus {
+        border: none;
+        color: $surface;
+        background: $surface;
+    }
+
+    SubmitCancelButton:hover {
+        border: none;
+        background: $surface;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__("▶️", **kwargs)
+        self.id = "submit-cancel-button"
+
+    def watch_is_cancel_mode(self, is_cancel: bool) -> None:
+        """Update the button label when cancel mode changes."""
+        self.label = "⏹️" if is_cancel else "▶️"
+
+    def on_click(self) -> None:
+        """Handle click event and bubble it up to parent."""
+        # When clicked, send a ButtonClicked message that will be handled by the parent
+        self.post_message(self.Clicked(self))
+
+    class Clicked(Message):
+        """Button was clicked."""
+
+        def __init__(self, button: "SubmitCancelButton") -> None:
+            self.is_cancel_mode = button.is_cancel_mode
+            super().__init__()
+
+
+class InputArea(Container):
+    """Input area with text input, spinner, help text, and send button."""
+
+    DEFAULT_CSS = """
+    InputArea {
+        dock: bottom;
+        height: 9;
+        margin: 1;
+    }
+
+    #spinner {
+        height: 1;
+        width: 1fr;
+        margin: 0 3 0 1;
+        content-align: left middle;
+        text-align: left;
+        display: none;
+    }
+
+    #spinner.visible {
+        display: block;
+    }
+
+    #input-container {
+        height: 5;
+        width: 1fr;
+        margin: 1 3 0 1;
+        align: center middle;
+    }
+
+    #input-field {
+        height: 5;
+        width: 1fr;
+        border: round $primary;
+        background: $surface;
+    }
+
+    #submit-cancel-button {
+        height: 3;
+        width: 3;
+        min-width: 3;
+        margin: 1 0 1 1;
+        content-align: center middle;
+        border: none;
+        background: $surface;
+    }
+
+    #input-help {
+        height: 1;
+        width: 1fr;
+        margin: 0 3 1 1;
+        color: $text-muted;
+        text-align: center;
+    }
+    """
+
+    def on_mount(self) -> None:
+        """Initialize the button state based on the app's agent_busy state."""
+        app = self.app
+        if hasattr(app, "agent_busy"):
+            button = self.query_one(SubmitCancelButton)
+            button.is_cancel_mode = app.agent_busy
+
+    def compose(self) -> ComposeResult:
+        yield SimpleSpinnerWidget(id="spinner")
+        with Horizontal(id="input-container"):
+            yield CustomTextArea(id="input-field", show_line_numbers=False)
+            yield SubmitCancelButton()
+        yield Static(
+            "Enter to send • Alt+Enter for new line • Ctrl+1 for help",
+            id="input-help",
+        )
+
+    def on_submit_cancel_button_clicked(
+        self, event: SubmitCancelButton.Clicked
+    ) -> None:
+        """Handle button clicks based on current mode."""
+        if event.is_cancel_mode:
+            # Cancel mode - stop the current process
+            self.post_message(self.CancelRequested())
+        else:
+            # Submit mode - send the message
+            self.post_message(self.SubmitRequested())
+
+        # Return focus to the input field
+        self.app.call_after_refresh(self.focus_input_field)
+
+    def focus_input_field(self) -> None:
+        """Focus the input field after button click."""
+        input_field = self.query_one("#input-field")
+        input_field.focus()
+
+    class SubmitRequested(Message):
+        """Request to submit the current input."""
+
+        pass
+
+    class CancelRequested(Message):
+        """Request to cancel the current process."""
+
+        pass