code-puppy 0.0.123__py3-none-any.whl → 0.0.125__py3-none-any.whl

code_puppy/tui/components/status_bar.py

@@ -101,15 +101,15 @@ class StatusBar(Static):
         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
+            from code_puppy.config import get_compaction_threshold
 
-            summarization_threshold = get_summarization_threshold()
+            get_compaction_threshold = get_compaction_threshold()
 
-            if self.token_proportion > summarization_threshold:
+            if self.token_proportion > get_compaction_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
+                get_compaction_threshold - 0.15
             ):  # 15% before summarization threshold
                 token_color = "yellow"
                 token_status = f"🟡 {self.token_count}/{self.token_capacity} ({self.token_proportion:.1%})"

code_puppy/tui/screens/settings.py

@@ -100,9 +100,20 @@ class SettingsScreen(ModalScreen):
                     )
 
                 with Container(classes="setting-row"):
-                    yield Static("Summary Threshold:", classes="setting-label")
+                    yield Static("Compaction Strategy:", classes="setting-label")
+                    yield Select(
+                        [
+                            ("Summarization", "summarization"),
+                            ("Truncation", "truncation"),
+                        ],
+                        id="compaction-strategy-select",
+                        classes="setting-input",
+                    )
+
+                with Container(classes="setting-row"):
+                    yield Static("Compaction Threshold:", classes="setting-label")
                     yield Input(
-                        id="summary-threshold-input",
+                        id="compaction-threshold-input",
                         classes="setting-input",
                         placeholder="e.g., 0.85",
                     )
@@ -118,7 +129,8 @@ class SettingsScreen(ModalScreen):
             get_owner_name,
             get_protected_token_count,
             get_puppy_name,
-            get_summarization_threshold,
+            get_compaction_strategy,
+            get_compaction_threshold,
         )
 
         # Load current values
@@ -126,12 +138,18 @@ class SettingsScreen(ModalScreen):
         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)
+        compaction_threshold_input = self.query_one(
+            "#compaction-threshold-input", Input
+        )
+        compaction_strategy_select = self.query_one(
+            "#compaction-strategy-select", Select
+        )
 
         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())
+        compaction_threshold_input.value = str(get_compaction_threshold())
+        compaction_strategy_select.value = get_compaction_strategy()
 
         # Load available models
         self.load_model_options(model_select)
@@ -146,9 +164,7 @@ class SettingsScreen(ModalScreen):
         """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
@@ -171,7 +187,11 @@ class SettingsScreen(ModalScreen):
     @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
+        from code_puppy.config import (
+            set_config_value,
+            set_model_name,
+            get_model_context_length,
+        )
 
         try:
             # Get values from inputs
@@ -182,8 +202,8 @@ class SettingsScreen(ModalScreen):
             protected_tokens = self.query_one(
                 "#protected-tokens-input", Input
             ).value.strip()
-            summary_threshold = self.query_one(
-                "#summary-threshold-input", Input
+            compaction_threshold = self.query_one(
+                "#compaction-threshold-input", Input
             ).value.strip()
 
             # Validate and save
@@ -201,31 +221,46 @@ class SettingsScreen(ModalScreen):
             # Validate and save protected tokens
             if protected_tokens.isdigit():
                 tokens_value = int(protected_tokens)
+                model_context_length = get_model_context_length()
+                max_protected_tokens = int(model_context_length * 0.75)
+
                 if tokens_value >= 1000:  # Minimum validation
-                    set_config_value("protected_token_count", protected_tokens)
+                    if tokens_value <= max_protected_tokens:  # Maximum validation
+                        set_config_value("protected_token_count", protected_tokens)
+                    else:
+                        raise ValueError(
+                            f"Protected tokens must not exceed 75% of model context length ({max_protected_tokens} tokens for current model)"
+                        )
                 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:
+            # Validate and save compaction threshold
+            if compaction_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)
+                    threshold_value = float(compaction_threshold)
+                    if 0.8 <= threshold_value <= 0.95:  # Same bounds as config function
+                        set_config_value("compaction_threshold", compaction_threshold)
                     else:
                         raise ValueError(
-                            "Summary threshold must be between 0.1 and 0.95"
+                            "Compaction threshold must be between 0.8 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"
+                            "Compaction threshold must be a valid decimal number"
                         )
 
+            # Save compaction strategy
+            compaction_strategy = self.query_one(
+                "#compaction-strategy-select", Select
+            ).value
+            if compaction_strategy in ["summarization", "truncation"]:
+                set_config_value("compaction_strategy", compaction_strategy)
+
             # Return success message with model change info
             message = "Settings saved successfully!"
             if selected_model:

code_puppy/tui/tests/test_agent_command.py

@@ -0,0 +1,72 @@
+"""Tests for the /agent command handling in TUI mode."""
+
+from unittest.mock import patch, MagicMock
+
+from code_puppy.tui.app import CodePuppyTUI
+
+
+class TestTUIAgentCommand:
+    """Test the TUI's handling of /agent commands."""
+
+    @patch("code_puppy.tui.app.get_code_generation_agent")
+    @patch("code_puppy.tui.app.handle_command")
+    def test_tui_handles_agent_command(self, mock_handle_command, mock_get_agent):
+        """Test that TUI properly delegates /agent commands to command handler."""
+        # Create a TUI app instance
+        app = CodePuppyTUI()
+
+        # Mock the agent
+        mock_agent_instance = MagicMock()
+        mock_get_agent.return_value = mock_agent_instance
+
+        # Mock handle_command to simulate successful processing
+        mock_handle_command.return_value = True
+
+        # Simulate processing an /agent command
+        message = "/agent code-puppy"
+        app.agent = mock_agent_instance
+
+        # Call the method that processes messages
+        # We'll need to mock some UI elements to avoid complex setup
+        with (
+            patch.object(app, "add_user_message"),
+            patch.object(app, "_update_submit_cancel_button"),
+            patch.object(app, "start_agent_progress"),
+            patch.object(app, "stop_agent_progress"),
+            patch.object(app, "refresh_history_display"),
+        ):
+            import asyncio
+
+            # Create an event loop for the async test
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(app.process_message(message))
+
+        # Verify that handle_command was called with the correct argument
+        mock_handle_command.assert_called_once_with(message)
+
+        # Verify that get_code_generation_agent was called to refresh the agent instance
+        mock_get_agent.assert_called()
+
+    @patch("code_puppy.tui.app.get_code_generation_agent")
+    def test_tui_refreshes_agent_after_command(self, mock_get_agent):
+        """Test that TUI refreshes its agent instance after processing /agent command."""
+        # Create a TUI app instance
+        app = CodePuppyTUI()
+
+        # Set initial agent
+        initial_agent = MagicMock()
+        app.agent = initial_agent
+
+        # Mock get_code_generation_agent to return a new agent instance
+        new_agent = MagicMock()
+        mock_get_agent.return_value = new_agent
+
+        # Simulate that an /agent command was processed
+        with patch("code_puppy.tui.app.handle_command"):
+            import asyncio
+
+            loop = asyncio.get_event_loop()
+            loop.run_until_complete(app.process_message("/agent code-puppy"))
+
+        # Verify that the agent was refreshed
+        mock_get_agent.assert_called()