code-puppy 0.0.135__py3-none-any.whl → 0.0.136__py3-none-any.whl

code_puppy/messaging/message_queue.py

@@ -201,45 +201,50 @@ class MessageQueue:
         """Create a human input request and return its unique ID."""
         self._prompt_id_counter += 1
         prompt_id = f"prompt_{self._prompt_id_counter}"
-        
+
         # Emit the human input request message
         message = UIMessage(
             type=MessageType.HUMAN_INPUT_REQUEST,
             content=prompt_text,
-            metadata={"prompt_id": prompt_id}
+            metadata={"prompt_id": prompt_id},
         )
         self.emit(message)
-        
+
         return prompt_id
 
     def wait_for_prompt_response(self, prompt_id: str, timeout: float = None) -> str:
         """Wait for a response to a human input request."""
         import time
+
         start_time = time.time()
-        
+
         # Check if we're in TUI mode - if so, try to yield control to the event loop
         from code_puppy.state_management import is_tui_mode
+
         sleep_interval = 0.05 if is_tui_mode() else 0.1
-        
+
         # Debug logging for TUI mode
         if is_tui_mode():
             print(f"[DEBUG] Waiting for prompt response: {prompt_id}")
-        
+
         while True:
             if prompt_id in self._prompt_responses:
                 response = self._prompt_responses.pop(prompt_id)
                 if is_tui_mode():
                     print(f"[DEBUG] Got response for {prompt_id}: {response[:20]}...")
                 return response
-            
+
             if timeout and (time.time() - start_time) > timeout:
-                raise TimeoutError(f"No response received for prompt {prompt_id} within {timeout} seconds")
-            
+                raise TimeoutError(
+                    f"No response received for prompt {prompt_id} within {timeout} seconds"
+                )
+
             time.sleep(sleep_interval)
 
     def provide_prompt_response(self, prompt_id: str, response: str):
         """Provide a response to a human input request."""
         from code_puppy.state_management import is_tui_mode
+
         if is_tui_mode():
             print(f"[DEBUG] Providing response for {prompt_id}: {response[:20]}...")
         self._prompt_responses[prompt_id] = response
@@ -343,25 +348,27 @@ def emit_divider(content: str = "[dim]" + "─" * 100 + "\n" + "[/dim]", **metad
 def emit_prompt(prompt_text: str, timeout: float = None) -> str:
     """Emit a human input request and wait for response."""
     from code_puppy.state_management import is_tui_mode
-    
+
     # In interactive mode, use direct input instead of the queue system
     if not is_tui_mode():
         # Emit the prompt as a message for display
         from code_puppy.messaging import emit_info
+
         emit_info(f"[yellow]{prompt_text}[/yellow]")
-        
+
         # Get input directly
         try:
             # Try to use rich console for better formatting
             from rich.console import Console
+
             console = Console()
             response = console.input("[cyan]>>> [/cyan]")
             return response
-        except:
+        except Exception:
             # Fallback to basic input
             response = input(">>> ")
             return response
-    
+
     # In TUI mode, use the queue system
     queue = get_global_queue()
     prompt_id = queue.create_prompt_request(prompt_text)

code_puppy/messaging/renderers.py

@@ -221,41 +221,53 @@ class TUIRenderer(MessageRenderer):
     async def _handle_human_input_request(self, message: UIMessage):
         """Handle a human input request in TUI mode."""
         try:
-            print(f"[DEBUG] TUI renderer handling human input request")
-            
+            print("[DEBUG] TUI renderer handling human input request")
+
             # Check if tui_app is available
             if not self.tui_app:
-                print(f"[DEBUG] No tui_app available, falling back to error response")
-                prompt_id = message.metadata.get("prompt_id") if message.metadata else None
+                print("[DEBUG] No tui_app available, falling back to error response")
+                prompt_id = (
+                    message.metadata.get("prompt_id") if message.metadata else None
+                )
                 if prompt_id:
                     from code_puppy.messaging import provide_prompt_response
+
                     provide_prompt_response(prompt_id, "")
                 return
-            
+
             prompt_id = message.metadata.get("prompt_id") if message.metadata else None
             if not prompt_id:
-                print(f"[DEBUG] No prompt_id in message metadata")
+                print("[DEBUG] No prompt_id in message metadata")
                 self.tui_app.add_error_message("Error: Invalid human input request")
                 return
 
             # For now, use a simple fallback instead of modal to avoid crashes
-            print(f"[DEBUG] Using fallback approach - showing prompt as message")
-            self.tui_app.add_system_message(f"[yellow]INPUT NEEDED:[/yellow] {str(message.content)}")
-            self.tui_app.add_system_message("[dim]This would normally show a modal, but using fallback to prevent crashes[/dim]")
-            
+            print("[DEBUG] Using fallback approach - showing prompt as message")
+            self.tui_app.add_system_message(
+                f"[yellow]INPUT NEEDED:[/yellow] {str(message.content)}"
+            )
+            self.tui_app.add_system_message(
+                "[dim]This would normally show a modal, but using fallback to prevent crashes[/dim]"
+            )
+
             # Provide empty response for now to unblock the waiting thread
             from code_puppy.messaging import provide_prompt_response
+
             provide_prompt_response(prompt_id, "")
-                
+
         except Exception as e:
             print(f"[DEBUG] Top-level exception in _handle_human_input_request: {e}")
             import traceback
+
             traceback.print_exc()
             # Last resort - provide empty response to prevent hanging
             try:
-                prompt_id = message.metadata.get("prompt_id") if message.metadata else None
+                prompt_id = (
+                    message.metadata.get("prompt_id") if message.metadata else None
+                )
                 if prompt_id:
                     from code_puppy.messaging import provide_prompt_response
+
                     provide_prompt_response(prompt_id, "")
             except Exception:
                 pass  # Can't do anything more
@@ -374,7 +386,9 @@ class SynchronousInteractiveRenderer:
         """Handle a human input request in interactive mode."""
         prompt_id = message.metadata.get("prompt_id") if message.metadata else None
         if not prompt_id:
-            self.console.print("[bold red]Error: Invalid human input request[/bold red]")
+            self.console.print(
+                "[bold red]Error: Invalid human input request[/bold red]"
+            )
             return
 
         # Display the prompt
@@ -386,11 +400,12 @@ class SynchronousInteractiveRenderer:
         try:
             # Use basic input for now - could be enhanced with prompt_toolkit later
             response = input(">>> ")
-            
+
             # Provide the response back to the queue
             from .message_queue import provide_prompt_response
+
             provide_prompt_response(prompt_id, response)
-            
+
         except (EOFError, KeyboardInterrupt):
             # Handle Ctrl+C or Ctrl+D
             provide_prompt_response(prompt_id, "")

code_puppy/state_management.py

@@ -1,18 +1,43 @@
 from typing import Any, List
 
+# Legacy global state - maintained for backward compatibility
 _message_history: List[Any] = []
 _compacted_message_hashes = set()
+
+# Flag to control whether to use agent-specific history (True) or global history (False)
+_use_agent_specific_history = True
 _tui_mode: bool = False
 _tui_app_instance: Any = None
 
 
 def add_compacted_message_hash(message_hash: str) -> None:
     """Add a message hash to the set of compacted message hashes."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                add_current_agent_compacted_message_hash,
+            )
+
+            add_current_agent_compacted_message_hash(message_hash)
+            return
+        except Exception:
+            # Fallback to global if agent system fails
+            pass
     _compacted_message_hashes.add(message_hash)
 
 
 def get_compacted_message_hashes():
     """Get the set of compacted message hashes."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                get_current_agent_compacted_message_hashes,
+            )
+
+            return get_current_agent_compacted_message_hashes()
+        except Exception:
+            # Fallback to global if agent system fails
+            pass
     return _compacted_message_hashes
 
 
@@ -64,27 +89,105 @@ def get_tui_mode() -> bool:
 
 
 def get_message_history() -> List[Any]:
+    """Get message history - uses agent-specific history if enabled, otherwise global."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                get_current_agent_message_history,
+            )
+
+            return get_current_agent_message_history()
+        except Exception:
+            # Fallback to global if agent system fails
+            return _message_history
     return _message_history
 
 
 def set_message_history(history: List[Any]) -> None:
+    """Set message history - uses agent-specific history if enabled, otherwise global."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                set_current_agent_message_history,
+            )
+
+            set_current_agent_message_history(history)
+            return
+        except Exception:
+            # Fallback to global if agent system fails
+            pass
     global _message_history
     _message_history = history
 
 
 def clear_message_history() -> None:
+    """Clear message history - uses agent-specific history if enabled, otherwise global."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                clear_current_agent_message_history,
+            )
+
+            clear_current_agent_message_history()
+            return
+        except Exception:
+            # Fallback to global if agent system fails
+            pass
     global _message_history
     _message_history = []
 
 
 def append_to_message_history(message: Any) -> None:
+    """Append to message history - uses agent-specific history if enabled, otherwise global."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                append_to_current_agent_message_history,
+            )
+
+            append_to_current_agent_message_history(message)
+            return
+        except Exception:
+            # Fallback to global if agent system fails
+            pass
     _message_history.append(message)
 
 
 def extend_message_history(history: List[Any]) -> None:
+    """Extend message history - uses agent-specific history if enabled, otherwise global."""
+    if _use_agent_specific_history:
+        try:
+            from code_puppy.agents.agent_manager import (
+                extend_current_agent_message_history,
+            )
+
+            extend_current_agent_message_history(history)
+            return
+        except Exception:
+            # Fallback to global if agent system fails
+            pass
     _message_history.extend(history)
 
 
+def set_use_agent_specific_history(enabled: bool) -> None:
+    """Enable or disable agent-specific message history.
+
+    Args:
+        enabled: True to use per-agent history, False to use global history.
+    """
+    global _use_agent_specific_history
+    _use_agent_specific_history = enabled
+
+
+def is_using_agent_specific_history() -> bool:
+    """Check if agent-specific message history is enabled.
+
+    Returns:
+        True if using per-agent history, False if using global history.
+    """
+    return _use_agent_specific_history
+
+
 def hash_message(message):
     hashable_entities = []
     for part in message.parts:

code_puppy/tui/app.py

@@ -46,7 +46,7 @@ from .. import state_management
 # Import shared message classes
 from .messages import CommandSelected, HistoryEntrySelected
 from .models import ChatMessage, MessageType
-from .screens import HelpScreen, SettingsScreen, ToolsScreen, MCPInstallWizardScreen
+from .screens import HelpScreen, MCPInstallWizardScreen, SettingsScreen, ToolsScreen
 
 
 class CodePuppyTUI(App):
@@ -88,6 +88,7 @@ class CodePuppyTUI(App):
     # Reactive variables for app state
     current_model = reactive("")
     puppy_name = reactive("")
+    current_agent = reactive("")
     agent_busy = reactive(False)
 
     def watch_agent_busy(self) -> None:
@@ -95,6 +96,35 @@ class CodePuppyTUI(App):
         # Update the submit/cancel button state when agent_busy changes
         self._update_submit_cancel_button(self.agent_busy)
 
+    def watch_current_agent(self) -> None:
+        """Watch for changes to current_agent and update title."""
+        self._update_title()
+
+    def _update_title(self) -> None:
+        """Update the application title to include current agent."""
+        if self.current_agent:
+            self.title = f"Code Puppy - {self.current_agent}"
+            self.sub_title = "TUI Mode"
+        else:
+            self.title = "Code Puppy - AI Code Assistant"
+            self.sub_title = "TUI Mode"
+
+    def _on_agent_reload(self, agent_id: str, agent_name: str) -> None:
+        """Callback for when agent is reloaded/changed."""
+        # Get the updated agent configuration
+        from code_puppy.agents.agent_manager import get_current_agent_config
+
+        current_agent_config = get_current_agent_config()
+        new_agent_display = (
+            current_agent_config.display_name if current_agent_config else "code-puppy"
+        )
+
+        # Update the reactive variable (this will trigger watch_current_agent)
+        self.current_agent = new_agent_display
+
+        # Add a system message to notify the user
+        self.add_system_message(f"🔄 Switched to agent: {new_agent_display}")
+
     def __init__(self, initial_command: str = None, **kwargs):
         super().__init__(**kwargs)
         self.agent_manager = None
@@ -123,10 +153,26 @@ class CodePuppyTUI(App):
 
         set_tui_app_instance(self)
 
+        # Register callback for agent reload events
+        from code_puppy.callbacks import register_callback
+
+        register_callback("agent_reload", self._on_agent_reload)
+
         # Load configuration
         self.current_model = get_model_name()
         self.puppy_name = get_puppy_name()
 
+        # Get current agent information
+        from code_puppy.agents.agent_manager import get_current_agent_config
+
+        current_agent_config = get_current_agent_config()
+        self.current_agent = (
+            current_agent_config.display_name if current_agent_config else "code-puppy"
+        )
+
+        # Initial title update
+        self._update_title()
+
         # Use runtime manager to ensure we always have the current agent
         self.agent_manager = get_runtime_agent_manager()
 
@@ -143,7 +189,9 @@ class CodePuppyTUI(App):
 
         # Get current agent and display info
         get_code_generation_agent()
-        self.add_system_message(f"🐕 Loaded agent '{self.puppy_name}' with model '{self.current_model}'")
+        self.add_system_message(
+            f"🐕 Loaded agent '{self.puppy_name}' with model '{self.current_model}'"
+        )
 
         # Start the message renderer EARLY to catch startup messages
         # Using call_after_refresh to start it as soon as possible after mount
@@ -632,16 +680,20 @@ class CodePuppyTUI(App):
 
     def action_open_mcp_wizard(self) -> None:
         """Open the MCP Install Wizard."""
-        
+
         def handle_wizard_result(result):
             if result and result.get("success"):
                 # Show success message
-                self.add_system_message(result.get("message", "MCP server installed successfully"))
-                
+                self.add_system_message(
+                    result.get("message", "MCP server installed successfully")
+                )
+
                 # If a server was installed, suggest starting it
                 if result.get("server_name"):
                     server_name = result["server_name"]
-                    self.add_system_message(f"💡 Use '/mcp start {server_name}' to start the server")
+                    self.add_system_message(
+                        f"💡 Use '/mcp start {server_name}' to start the server"
+                    )
             elif (
                 result
                 and not result.get("success")
@@ -649,7 +701,7 @@ class CodePuppyTUI(App):
             ):
                 # Show error message (but not for cancellation)
                 self.add_error_message(result.get("message", "MCP installation failed"))
-        
+
         self.push_screen(MCPInstallWizardScreen(), handle_wizard_result)
 
     def process_initial_command(self) -> None:
@@ -905,6 +957,11 @@ class CodePuppyTUI(App):
     async def on_unmount(self):
         """Clean up when the app is unmounted."""
         try:
+            # Unregister the agent reload callback
+            from code_puppy.callbacks import unregister_callback
+
+            unregister_callback("agent_reload", self._on_agent_reload)
+
             await self.stop_message_renderer()
         except Exception as e:
             # Log unmount errors but don't crash during cleanup

code_puppy/tui/components/chat_view.py

@@ -11,7 +11,7 @@ from rich.syntax import Syntax
 from rich.text import Text
 from textual import on
 from textual.containers import Vertical, VerticalScroll
-from textual.widgets import Static, Collapsible
+from textual.widgets import Static
 
 from ..models import ChatMessage, MessageType
 from .copy_button import CopyButton
@@ -342,14 +342,14 @@ class ChatView(VerticalScroll):
 
         if message.type == MessageType.USER:
             # Add user indicator and make it stand out
-            content_lines = message.content.split('\n')
+            content_lines = message.content.split("\n")
             if len(content_lines) > 1:
                 # Multi-line user message
                 formatted_content = f"╔══ USER ══╗\n{message.content}\n╚══════════╝"
             else:
                 # Single line user message
                 formatted_content = f"▶ USER: {message.content}"
-            
+
             message_widget = Static(Text(formatted_content), classes=css_class)
             # User messages are not collapsible - mount directly
             self.mount(message_widget)

code_puppy/tui/components/human_input_modal.py

@@ -7,7 +7,7 @@ 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, TextArea
+from textual.widgets import Button, Static, TextArea
 
 try:
     from .custom_widgets import CustomTextArea
@@ -109,13 +109,14 @@ class HumanInputModal(ModalScreen):
     def on_mount(self) -> None:
         """Focus the input field when modal opens."""
         try:
-            print(f"[DEBUG] Modal on_mount called")
+            print("[DEBUG] Modal on_mount called")
             input_field = self.query_one("#response-input", CustomTextArea)
             input_field.focus()
-            print(f"[DEBUG] Modal input field focused")
+            print("[DEBUG] Modal input field focused")
         except Exception as e:
             print(f"[DEBUG] Modal on_mount exception: {e}")
             import traceback
+
             traceback.print_exc()
 
     @on(Button.Pressed, "#submit-button")
@@ -123,7 +124,7 @@ class HumanInputModal(ModalScreen):
         """Handle submit button click."""
         self._submit_response()
 
-    @on(Button.Pressed, "#cancel-button") 
+    @on(Button.Pressed, "#cancel-button")
     def on_cancel_clicked(self) -> None:
         """Handle cancel button click."""
         self._cancel_response()
@@ -149,23 +150,26 @@ class HumanInputModal(ModalScreen):
             input_field = self.query_one("#response-input", CustomTextArea)
             self.response = input_field.text.strip()
             print(f"[DEBUG] Modal submitting response: {self.response[:20]}...")
-            
+
             # Provide the response back to the message queue
             from code_puppy.messaging import provide_prompt_response
+
             provide_prompt_response(self.prompt_id, self.response)
-            
+
             # Close the modal using the same method as other modals
             self.app.pop_screen()
         except Exception as e:
             print(f"[DEBUG] Modal error during submit: {e}")
             # If something goes wrong, provide empty response
             from code_puppy.messaging import provide_prompt_response
+
             provide_prompt_response(self.prompt_id, "")
             self.app.pop_screen()
 
     def _cancel_response(self) -> None:
         """Cancel the input request."""
-        print(f"[DEBUG] Modal cancelling response")
+        print("[DEBUG] Modal cancelling response")
         from code_puppy.messaging import provide_prompt_response
+
         provide_prompt_response(self.prompt_id, "")
-        self.app.pop_screen()
+        self.app.pop_screen()

code_puppy/tui/screens/__init__.py

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