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

code_puppy/tui/screens/help.py

@@ -0,0 +1,130 @@
+"""
+Help modal screen.
+"""
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+
+class HelpScreen(ModalScreen):
+    """Help modal screen."""
+
+    DEFAULT_CSS = """
+    HelpScreen {
+        align: center middle;
+    }
+
+    #help-dialog {
+        width: 80;
+        height: 30;
+        border: thick $primary;
+        background: $surface;
+        padding: 1;
+    }
+
+    #help-content {
+        height: 1fr;
+        margin: 0 0 1 0;
+        overflow-y: auto;
+    }
+
+    #help-buttons {
+        layout: horizontal;
+        height: 3;
+        align: center middle;
+    }
+
+    #dismiss-button {
+        margin: 0 1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Container(id="help-dialog"):
+            yield Static("📚 Code Puppy TUI Help", id="help-title")
+            with VerticalScroll(id="help-content"):
+                yield Static(self.get_help_content(), id="help-text")
+            with Container(id="help-buttons"):
+                yield Button("Dismiss", id="dismiss-button", variant="primary")
+
+    def get_help_content(self) -> str:
+        """Get the help content text."""
+        try:
+            # Get terminal width for responsive help
+            terminal_width = self.app.size.width if hasattr(self.app, "size") else 80
+        except Exception:
+            terminal_width = 80
+
+        if terminal_width < 60:
+            # Compact help for narrow terminals
+            return """
+Code Puppy TUI (Compact Mode):
+
+Controls:
+- Enter: Send message
+- Ctrl+Enter: New line
+- Ctrl+Q: Quit
+- Ctrl+2: Toggle History
+- Ctrl+3: Settings
+- Ctrl+4: Tools
+- Ctrl+5: Focus prompt
+- Ctrl+6: Focus response
+
+Use this help for full details.
+"""
+        else:
+            # Full help text
+            return """
+Code Puppy TUI Help:
+
+Input Controls:
+- Enter: Send message
+- ALT+Enter: New line (multi-line input)
+- Standard text editing shortcuts supported
+
+Keyboard Shortcuts:
+- Ctrl+Q/Ctrl+C: Quit application
+- Ctrl+L: Clear chat history
+- Ctrl+1: Show this help
+- Ctrl+2: Toggle History
+- Ctrl+3: Open settings
+- Ctrl+4: Tools
+- Ctrl+5: Focus prompt (input field)
+- Ctrl+6: Focus response (chat area)
+
+Chat Navigation:
+- Ctrl+Up/Down: Scroll chat up/down
+- Ctrl+Home: Scroll to top
+- Ctrl+End: Scroll to bottom
+
+Commands:
+- /clear: Clear chat history
+- /m <model>: Switch model
+- /cd <dir>: Change directory
+- /help: Show help
+- /status: Show current status
+
+Use the input area at the bottom to type messages.
+Press Ctrl+2 to view History when needed.
+Agent responses support syntax highlighting for code blocks.
+Press Ctrl+3 to access all configuration settings.
+
+Copy Feature:
+- 📋 Copy buttons appear after agent responses
+- Click or press Enter/Space on copy button to copy content
+- Raw markdown content is copied to clipboard
+- Visual feedback shows copy success/failure
+"""
+
+    @on(Button.Pressed, "#dismiss-button")
+    def dismiss_help(self) -> None:
+        """Dismiss the help modal."""
+        self.dismiss()
+
+    def on_key(self, event) -> None:
+        """Handle key events."""
+        if event.key == "escape":
+            self.dismiss()

code_puppy/tui/screens/settings.py

@@ -0,0 +1,256 @@
+"""
+Settings modal screen.
+"""
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Select, Static
+
+
+class SettingsScreen(ModalScreen):
+    """Settings configuration screen."""
+
+    DEFAULT_CSS = """
+    SettingsScreen {
+        align: center middle;
+    }
+
+    #settings-dialog {
+        width: 80;
+        height: 33;
+        border: thick $primary;
+        background: $surface;
+        padding: 1;
+    }
+
+    #settings-form {
+        height: 1fr;
+    }
+
+    .setting-row {
+        layout: horizontal;
+        height: 3;
+        margin: 0 0 1 0;
+    }
+
+    .setting-label {
+        width: 20;
+        text-align: right;
+        padding: 1 1 0 0;
+    }
+
+    .setting-input {
+        width: 1fr;
+        margin: 0 0 0 1;
+    }
+
+    /* Additional styling for static input values */
+    #yolo-static {
+        padding: 1 0 0 0;  /* Align text vertically with other inputs */
+        color: $success;   /* Use success color to emphasize it's enabled */
+    }
+
+    #settings-buttons {
+        layout: horizontal;
+        height: 3;
+        align: center middle;
+    }
+
+    #save-button, #cancel-button {
+        margin: 0 1;
+    }
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.settings_data = {}
+
+    def compose(self) -> ComposeResult:
+        with Container(id="settings-dialog"):
+            yield Static("⚙️  Settings Configuration", id="settings-title")
+            with Container(id="settings-form"):
+                with Container(classes="setting-row"):
+                    yield Static("Puppy Name:", classes="setting-label")
+                    yield Input(id="puppy-name-input", classes="setting-input")
+
+                with Container(classes="setting-row"):
+                    yield Static("Owner Name:", classes="setting-label")
+                    yield Input(id="owner-name-input", classes="setting-input")
+
+                with Container(classes="setting-row"):
+                    yield Static("Model:", classes="setting-label")
+                    yield Select([], id="model-select", classes="setting-input")
+
+                with Container(classes="setting-row"):
+                    yield Static("YOLO Mode:", classes="setting-label")
+                    yield Static(
+                        "✅ Enabled (always on in TUI)",
+                        id="yolo-static",
+                        classes="setting-input",
+                    )
+
+                with Container(classes="setting-row"):
+                    yield Static("Protected Tokens:", classes="setting-label")
+                    yield Input(
+                        id="protected-tokens-input",
+                        classes="setting-input",
+                        placeholder="e.g., 50000",
+                    )
+
+                with Container(classes="setting-row"):
+                    yield Static("Summary Threshold:", classes="setting-label")
+                    yield Input(
+                        id="summary-threshold-input",
+                        classes="setting-input",
+                        placeholder="e.g., 0.85",
+                    )
+
+            with Container(id="settings-buttons"):
+                yield Button("Save", id="save-button", variant="primary")
+                yield Button("Cancel", id="cancel-button")
+
+    def on_mount(self) -> None:
+        """Load current settings when the screen mounts."""
+        from code_puppy.config import (
+            get_model_name,
+            get_owner_name,
+            get_protected_token_count,
+            get_puppy_name,
+            get_summarization_threshold,
+        )
+
+        # Load current values
+        puppy_name_input = self.query_one("#puppy-name-input", Input)
+        owner_name_input = self.query_one("#owner-name-input", Input)
+        model_select = self.query_one("#model-select", Select)
+        protected_tokens_input = self.query_one("#protected-tokens-input", Input)
+        summary_threshold_input = self.query_one("#summary-threshold-input", Input)
+
+        puppy_name_input.value = get_puppy_name() or ""
+        owner_name_input.value = get_owner_name() or ""
+        protected_tokens_input.value = str(get_protected_token_count())
+        summary_threshold_input.value = str(get_summarization_threshold())
+
+        # Load available models
+        self.load_model_options(model_select)
+
+        # Set current model selection
+        current_model = get_model_name()
+        model_select.value = current_model
+
+        # YOLO mode is always enabled in TUI mode
+
+    def load_model_options(self, model_select):
+        """Load available models into the model select widget."""
+        try:
+            # Use the same method that interactive mode uses to load models
+            import os
+
+            from code_puppy.config import CONFIG_DIR
+            from code_puppy.model_factory import ModelFactory
+
+            # Load models using the same path and method as interactive mode
+            models_config_path = os.path.join(CONFIG_DIR, "models.json")
+            models_data = ModelFactory.load_config(models_config_path)
+
+            # Create options as (display_name, model_name) tuples
+            model_options = []
+            for model_name, model_config in models_data.items():
+                model_type = model_config.get("type", "unknown")
+                display_name = f"{model_name} ({model_type})"
+                model_options.append((display_name, model_name))
+
+            # Set the options on the select widget
+            model_select.set_options(model_options)
+
+        except Exception:
+            # Fallback to a basic option if loading fails
+            model_select.set_options([("gpt-4.1 (openai)", "gpt-4.1")])
+
+    @on(Button.Pressed, "#save-button")
+    def save_settings(self) -> None:
+        """Save the modified settings."""
+        from code_puppy.config import set_config_value, set_model_name
+
+        try:
+            # Get values from inputs
+            puppy_name = self.query_one("#puppy-name-input", Input).value.strip()
+            owner_name = self.query_one("#owner-name-input", Input).value.strip()
+            selected_model = self.query_one("#model-select", Select).value
+            yolo_mode = "true"  # Always set to true in TUI mode
+            protected_tokens = self.query_one(
+                "#protected-tokens-input", Input
+            ).value.strip()
+            summary_threshold = self.query_one(
+                "#summary-threshold-input", Input
+            ).value.strip()
+
+            # Validate and save
+            if puppy_name:
+                set_config_value("puppy_name", puppy_name)
+            if owner_name:
+                set_config_value("owner_name", owner_name)
+
+            # Save model selection
+            if selected_model:
+                set_model_name(selected_model)
+
+            set_config_value("yolo_mode", yolo_mode)
+
+            # Validate and save protected tokens
+            if protected_tokens.isdigit():
+                tokens_value = int(protected_tokens)
+                if tokens_value >= 1000:  # Minimum validation
+                    set_config_value("protected_token_count", protected_tokens)
+                else:
+                    raise ValueError("Protected tokens must be at least 1000")
+            elif protected_tokens:  # If not empty but not digit
+                raise ValueError("Protected tokens must be a valid number")
+
+            # Validate and save summary threshold
+            if summary_threshold:
+                try:
+                    threshold_value = float(summary_threshold)
+                    if 0.1 <= threshold_value <= 0.95:  # Same bounds as config function
+                        set_config_value("summarization_threshold", summary_threshold)
+                    else:
+                        raise ValueError(
+                            "Summary threshold must be between 0.1 and 0.95"
+                        )
+                except ValueError as ve:
+                    if "must be between" in str(ve):
+                        raise ve
+                    else:
+                        raise ValueError(
+                            "Summary threshold must be a valid decimal number"
+                        )
+
+            # Return success message with model change info
+            message = "Settings saved successfully!"
+            if selected_model:
+                message += f" Model switched to: {selected_model}"
+
+            self.dismiss(
+                {
+                    "success": True,
+                    "message": message,
+                    "model_changed": bool(selected_model),
+                }
+            )
+
+        except Exception as e:
+            self.dismiss(
+                {"success": False, "message": f"Error saving settings: {str(e)}"}
+            )
+
+    @on(Button.Pressed, "#cancel-button")
+    def cancel_settings(self) -> None:
+        """Cancel settings changes."""
+        self.dismiss({"success": False, "message": "Settings cancelled"})
+
+    def on_key(self, event) -> None:
+        """Handle key events."""
+        if event.key == "escape":
+            self.cancel_settings()

code_puppy/tui/screens/tools.py

@@ -0,0 +1,74 @@
+"""
+Tools modal screen.
+"""
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Markdown, Static
+
+from code_puppy.tools.tools_content import tools_content
+
+
+class ToolsScreen(ModalScreen):
+    """Tools modal screen"""
+
+    DEFAULT_CSS = """
+    ToolsScreen {
+        align: center middle;
+    }
+
+    #tools-dialog {
+        width: 95;
+        height: 40;
+        border: thick $primary;
+        background: $surface;
+        padding: 1;
+    }
+
+    #tools-content {
+        height: 1fr;
+        margin: 0 0 1 0;
+        overflow-y: auto;
+    }
+
+    #tools-buttons {
+        layout: horizontal;
+        height: 3;
+        align: center middle;
+    }
+
+    #dismiss-button {
+        margin: 0 1;
+    }
+
+    #tools-markdown {
+        margin: 0;
+        padding: 0;
+    }
+
+    /* Style markdown elements for better readability */
+    Markdown {
+        margin: 0;
+        padding: 0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Container(id="tools-dialog"):
+            yield Static("🛠️  Cooper's Toolkit\n", id="tools-title")
+            with VerticalScroll(id="tools-content"):
+                yield Markdown(tools_content, id="tools-markdown")
+            with Container(id="tools-buttons"):
+                yield Button("Dismiss", id="dismiss-button", variant="primary")
+
+    @on(Button.Pressed, "#dismiss-button")
+    def dismiss_tools(self) -> None:
+        """Dismiss the tools modal."""
+        self.dismiss()
+
+    def on_key(self, event) -> None:
+        """Handle key events."""
+        if event.key == "escape":
+            self.dismiss()

code_puppy/tui/tests/__init__.py

@@ -0,0 +1 @@
+# Test package for tui

code_puppy/tui/tests/test_chat_message.py

@@ -0,0 +1,28 @@
+import unittest
+from datetime import datetime
+
+from code_puppy.tui.models.chat_message import ChatMessage
+from code_puppy.tui.models.enums import MessageType
+
+
+class TestChatMessage(unittest.TestCase):
+    def test_chat_message_defaults(self):
+        msg = ChatMessage(
+            id="1", type=MessageType.USER, content="hi", timestamp=datetime.now()
+        )
+        self.assertEqual(msg.metadata, {})
+
+    def test_chat_message_with_metadata(self):
+        meta = {"foo": "bar"}
+        msg = ChatMessage(
+            id="2",
+            type=MessageType.AGENT,
+            content="hello",
+            timestamp=datetime.now(),
+            metadata=meta,
+        )
+        self.assertEqual(msg.metadata, meta)
+
+
+if __name__ == "__main__":
+    unittest.main()

code_puppy/tui/tests/test_chat_view.py

@@ -0,0 +1,88 @@
+import unittest
+from datetime import datetime
+from unittest.mock import patch
+
+from code_puppy.tui.components.chat_view import ChatView
+from code_puppy.tui.models.chat_message import ChatMessage
+from code_puppy.tui.models.enums import MessageType
+
+
+class TestChatView(unittest.TestCase):
+    def setUp(self):
+        self.chat_view = ChatView()
+
+    @patch.object(ChatView, "mount")
+    def test_add_message_user(self, mock_mount):
+        msg = ChatMessage(
+            id="test-user-1",
+            type=MessageType.USER,
+            content="Hello",
+            timestamp=datetime.now(),
+        )
+        self.chat_view.add_message(msg)
+        self.assertIn(msg, self.chat_view.messages)
+        mock_mount.assert_called_once()
+
+    @patch.object(ChatView, "mount")
+    def test_add_message_agent(self, mock_mount):
+        msg = ChatMessage(
+            id="test-agent-1",
+            type=MessageType.AGENT,
+            content="Hi there!",
+            timestamp=datetime.now(),
+        )
+        self.chat_view.add_message(msg)
+        self.assertIn(msg, self.chat_view.messages)
+        mock_mount.assert_called_once()
+
+    @patch.object(ChatView, "mount")
+    def test_add_message_system(self, mock_mount):
+        msg = ChatMessage(
+            id="test-system-1",
+            type=MessageType.SYSTEM,
+            content="System message",
+            timestamp=datetime.now(),
+        )
+        self.chat_view.add_message(msg)
+        self.assertIn(msg, self.chat_view.messages)
+        mock_mount.assert_called_once()
+
+    @patch.object(ChatView, "mount")
+    def test_add_message_error(self, mock_mount):
+        msg = ChatMessage(
+            id="test-error-1",
+            type=MessageType.ERROR,
+            content="Error occurred",
+            timestamp=datetime.now(),
+        )
+        self.chat_view.add_message(msg)
+        self.assertIn(msg, self.chat_view.messages)
+        mock_mount.assert_called_once()
+
+    @patch.object(ChatView, "mount")
+    @patch.object(ChatView, "query")
+    def test_clear_messages(self, mock_query, mock_mount):
+        # Mock the query method to return empty iterables
+        mock_query.return_value = []
+
+        msg = ChatMessage(
+            id="test-clear-1",
+            type=MessageType.USER,
+            content="Hello",
+            timestamp=datetime.now(),
+        )
+        self.chat_view.add_message(msg)
+        self.chat_view.clear_messages()
+        self.assertEqual(len(self.chat_view.messages), 0)
+        # Verify that query was called to find widgets to remove
+        self.assertTrue(mock_query.called)
+
+    def test_render_agent_message_with_syntax(self):
+        prefix = "Agent: "
+        content = "Some text\n```python\nprint('hi')\n```"
+        group = self.chat_view._render_agent_message_with_syntax(prefix, content)
+        self.assertIsNotNone(group)
+
+
+if __name__ == "__main__":
+    unittest.main()

code_puppy/tui/tests/test_command_history.py

@@ -0,0 +1,89 @@
+import re
+import unittest
+from unittest.mock import MagicMock, patch
+
+from code_puppy.config import COMMAND_HISTORY_FILE
+from code_puppy.tui.app import CodePuppyTUI
+from code_puppy.tui.components.custom_widgets import CustomTextArea
+
+
+class TestCommandHistory(unittest.TestCase):
+    def setUp(self):
+        self.app = CodePuppyTUI()
+
+    @patch("builtins.open", new_callable=unittest.mock.mock_open)
+    def test_action_send_message_saves_to_history(self, mock_open):
+        # Setup test mocks
+        self.app.query_one = MagicMock()
+        input_field_mock = MagicMock(spec=CustomTextArea)
+        input_field_mock.text = "test command"
+        self.app.query_one.return_value = input_field_mock
+
+        # Mock other methods to prevent full execution
+        self.app.add_user_message = MagicMock()
+        self.app._update_submit_cancel_button = MagicMock()
+        self.app.run_worker = MagicMock()
+
+        # Execute
+        self.app.action_send_message()
+
+        # Assertions
+        mock_open.assert_called_once_with(COMMAND_HISTORY_FILE, "a")
+        # Check that write was called with timestamped format
+        write_calls = mock_open().write.call_args_list
+        self.assertEqual(len(write_calls), 1)
+        written_content = write_calls[0][0][0]
+        # Should match pattern: \n# YYYY-MM-DDTHH:MM:SS\ntest command\n
+        self.assertTrue(
+            re.match(
+                r"^\n# \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\ntest command\n$",
+                written_content,
+            )
+        )
+        self.app.add_user_message.assert_called_once_with("test command")
+
+    @patch("builtins.open", new_callable=unittest.mock.mock_open)
+    def test_action_send_message_empty_command(self, mock_open):
+        # Setup test mocks
+        self.app.query_one = MagicMock()
+        input_field_mock = MagicMock(spec=CustomTextArea)
+        input_field_mock.text = "   "  # Empty or whitespace-only command
+        self.app.query_one.return_value = input_field_mock
+
+        # Mock other methods
+        self.app.add_user_message = MagicMock()
+
+        # Execute
+        self.app.action_send_message()
+
+        # Assertions - nothing should happen with empty commands
+        mock_open.assert_not_called()
+        self.app.add_user_message.assert_not_called()
+
+    @patch("builtins.open")
+    def test_action_send_message_handles_error(self, mock_open):
+        # Setup test mocks
+        self.app.query_one = MagicMock()
+        input_field_mock = MagicMock(spec=CustomTextArea)
+        input_field_mock.text = "test command"
+        self.app.query_one.return_value = input_field_mock
+
+        # Mock other methods to prevent full execution
+        self.app.add_user_message = MagicMock()
+        self.app._update_submit_cancel_button = MagicMock()
+        self.app.run_worker = MagicMock()
+        self.app.add_error_message = MagicMock()
+
+        # Make open throw an exception
+        mock_open.side_effect = Exception("File error")
+
+        # Execute
+        self.app.action_send_message()
+
+        # Assertions - error is printed to stdout, not added to UI
+        # Message should still be processed despite error saving to history
+        self.app.add_user_message.assert_called_once_with("test command")
+
+
+if __name__ == "__main__":
+    unittest.main()