code-puppy 0.0.130__py3-none-any.whl → 0.0.132__py3-none-any.whl

code_puppy/mcp/system_tools.py

@@ -0,0 +1,214 @@
+"""
+System tool detection and validation for MCP server requirements.
+"""
+
+import shutil
+import subprocess
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass
+
+
+@dataclass
+class ToolInfo:
+    """Information about a detected system tool."""
+    name: str
+    available: bool
+    version: Optional[str] = None
+    path: Optional[str] = None
+    error: Optional[str] = None
+
+
+class SystemToolDetector:
+    """Detect and validate system tools required by MCP servers."""
+    
+    # Tool version commands
+    VERSION_COMMANDS = {
+        "node": ["node", "--version"],
+        "npm": ["npm", "--version"],
+        "npx": ["npx", "--version"],
+        "python": ["python", "--version"],
+        "python3": ["python3", "--version"],
+        "pip": ["pip", "--version"],
+        "pip3": ["pip3", "--version"],
+        "git": ["git", "--version"],
+        "docker": ["docker", "--version"],
+        "java": ["java", "-version"],
+        "go": ["go", "version"],
+        "rust": ["rustc", "--version"],
+        "cargo": ["cargo", "--version"],
+        "julia": ["julia", "--version"],
+        "R": ["R", "--version"],
+        "php": ["php", "--version"],
+        "ruby": ["ruby", "--version"],
+        "perl": ["perl", "--version"],
+        "swift": ["swift", "--version"],
+        "dotnet": ["dotnet", "--version"],
+        "jupyter": ["jupyter", "--version"],
+        "code": ["code", "--version"],  # VS Code
+        "vim": ["vim", "--version"],
+        "emacs": ["emacs", "--version"],
+    }
+    
+    @classmethod
+    def detect_tool(cls, tool_name: str) -> ToolInfo:
+        """Detect if a tool is available and get its version."""
+        # First check if tool is in PATH
+        tool_path = shutil.which(tool_name)
+        
+        if not tool_path:
+            return ToolInfo(
+                name=tool_name,
+                available=False,
+                error=f"{tool_name} not found in PATH"
+            )
+        
+        # Try to get version
+        version_cmd = cls.VERSION_COMMANDS.get(tool_name)
+        version = None
+        error = None
+        
+        if version_cmd:
+            try:
+                # Run version command
+                result = subprocess.run(
+                    version_cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=10
+                )
+                
+                if result.returncode == 0:
+                    # Parse version from output
+                    output = result.stdout.strip() or result.stderr.strip()
+                    version = cls._parse_version(tool_name, output)
+                else:
+                    error = f"Version check failed: {result.stderr.strip()}"
+                    
+            except subprocess.TimeoutExpired:
+                error = "Version check timed out"
+            except Exception as e:
+                error = f"Version check error: {str(e)}"
+        
+        return ToolInfo(
+            name=tool_name,
+            available=True,
+            version=version,
+            path=tool_path,
+            error=error
+        )
+    
+    @classmethod
+    def detect_tools(cls, tool_names: List[str]) -> Dict[str, ToolInfo]:
+        """Detect multiple tools."""
+        return {name: cls.detect_tool(name) for name in tool_names}
+    
+    @classmethod
+    def _parse_version(cls, tool_name: str, output: str) -> Optional[str]:
+        """Parse version string from command output."""
+        if not output:
+            return None
+        
+        # Common version patterns
+        import re
+        
+        # Try to find version pattern like "v1.2.3" or "1.2.3"
+        version_patterns = [
+            r'v?(\d+\.\d+\.\d+(?:\.\d+)?)',  # Standard semver
+            r'(\d+\.\d+\.\d+)',  # Simple version
+            r'version\s+v?(\d+\.\d+\.\d+)',  # "version 1.2.3"
+            r'v?(\d+\.\d+)',  # Major.minor only
+        ]
+        
+        for pattern in version_patterns:
+            match = re.search(pattern, output, re.IGNORECASE)
+            if match:
+                return match.group(1)
+        
+        # If no pattern matches, return first line (common for many tools)
+        first_line = output.split('\n')[0].strip()
+        if len(first_line) < 100:  # Reasonable length for a version string
+            return first_line
+        
+        return None
+    
+    @classmethod
+    def check_package_dependencies(cls, packages: List[str]) -> Dict[str, bool]:
+        """Check if package dependencies are available."""
+        results = {}
+        
+        for package in packages:
+            available = False
+            
+            # Try different package managers/methods
+            if package.startswith('@') or '/' in package:
+                # Likely npm package
+                available = cls._check_npm_package(package)
+            elif package in ['jupyter', 'pandas', 'numpy', 'matplotlib']:
+                # Python packages
+                available = cls._check_python_package(package)
+            else:
+                # Try both npm and python
+                available = cls._check_npm_package(package) or cls._check_python_package(package)
+            
+            results[package] = available
+        
+        return results
+    
+    @classmethod
+    def _check_npm_package(cls, package: str) -> bool:
+        """Check if an npm package is available."""
+        try:
+            result = subprocess.run(
+                ["npm", "list", "-g", package],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            return result.returncode == 0
+        except:
+            return False
+    
+    @classmethod
+    def _check_python_package(cls, package: str) -> bool:
+        """Check if a Python package is available."""
+        try:
+            import importlib
+            importlib.import_module(package)
+            return True
+        except ImportError:
+            return False
+    
+    @classmethod
+    def get_installation_suggestions(cls, tool_name: str) -> List[str]:
+        """Get installation suggestions for a missing tool."""
+        suggestions = {
+            "node": [
+                "Install Node.js from https://nodejs.org",
+                "Or use package manager: brew install node (macOS) / sudo apt install nodejs (Ubuntu)"
+            ],
+            "npm": ["Usually comes with Node.js - install Node.js first"],
+            "npx": ["Usually comes with npm 5.2+ - update npm: npm install -g npm"],
+            "python": [
+                "Install Python from https://python.org",
+                "Or use package manager: brew install python (macOS) / sudo apt install python3 (Ubuntu)"
+            ],
+            "python3": ["Same as python - install Python 3.x"],
+            "pip": ["Usually comes with Python - try: python -m ensurepip"],
+            "pip3": ["Usually comes with Python 3 - try: python3 -m ensurepip"],
+            "git": [
+                "Install Git from https://git-scm.com",
+                "Or use package manager: brew install git (macOS) / sudo apt install git (Ubuntu)"
+            ],
+            "docker": ["Install Docker from https://docker.com"],
+            "java": [
+                "Install OpenJDK from https://openjdk.java.net",
+                "Or use package manager: brew install openjdk (macOS) / sudo apt install default-jdk (Ubuntu)"
+            ],
+            "jupyter": ["Install with pip: pip install jupyter"],
+        }
+        
+        return suggestions.get(tool_name, [f"Please install {tool_name} manually"])
+
+
+# Global detector instance
+detector = SystemToolDetector()

code_puppy/messaging/__init__.py

@@ -10,12 +10,14 @@ from .message_queue import (
     emit_info,
     emit_message,
     emit_planned_next_steps,
+    emit_prompt,
     emit_success,
     emit_system_message,
     emit_tool_output,
     emit_warning,
     get_buffered_startup_messages,
     get_global_queue,
+    provide_prompt_response,
 )
 from .queue_console import QueueConsole, get_queue_console
 from .renderers import InteractiveRenderer, SynchronousInteractiveRenderer, TUIRenderer
@@ -37,6 +39,8 @@ __all__ = [
     "emit_planned_next_steps",
     "emit_agent_response",
     "emit_system_message",
+    "emit_prompt",
+    "provide_prompt_response",
     "get_buffered_startup_messages",
     "InteractiveRenderer",
     "TUIRenderer",

code_puppy/messaging/message_queue.py

@@ -37,6 +37,9 @@ class MessageType(Enum):
     AGENT_RESPONSE = "agent_response"
     AGENT_STATUS = "agent_status"
 
+    # Human interaction types
+    HUMAN_INPUT_REQUEST = "human_input_request"
+
     # System types
     SYSTEM = "system"
     DEBUG = "debug"
@@ -71,6 +74,8 @@ class MessageQueue:
         self._startup_buffer = []  # Buffer messages before any renderer starts
         self._has_active_renderer = False
         self._event_loop = None  # Store reference to the event loop
+        self._prompt_responses = {}  # Store responses to human input requests
+        self._prompt_id_counter = 0  # Counter for unique prompt IDs
 
     def start(self):
         """Start the queue processing."""
@@ -192,6 +197,53 @@ class MessageQueue:
         """Mark that no renderer is currently active."""
         self._has_active_renderer = False
 
+    def create_prompt_request(self, prompt_text: str) -> str:
+        """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}
+        )
+        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")
+            
+            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
+
 
 # Global message queue instance
 _global_queue: Optional[MessageQueue] = None
@@ -286,3 +338,37 @@ def emit_divider(content: str = "[dim]" + "─" * 100 + "\n" + "[/dim]", **metad
         emit_message(MessageType.DIVIDER, content, **metadata)
     else:
         pass
+
+
+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:
+            # 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)
+    return queue.wait_for_prompt_response(prompt_id, timeout)
+
+
+def provide_prompt_response(prompt_id: str, response: str):
+    """Provide a response to a human input request."""
+    queue = get_global_queue()
+    queue.provide_prompt_response(prompt_id, response)

code_puppy/messaging/renderers.py

@@ -81,6 +81,11 @@ class InteractiveRenderer(MessageRenderer):
 
     async def render_message(self, message: UIMessage):
         """Render a message using Rich console."""
+        # Handle human input requests
+        if message.type == MessageType.HUMAN_INPUT_REQUEST:
+            await self._handle_human_input_request(message)
+            return
+
         # Convert message type to appropriate Rich styling
         if message.type == MessageType.ERROR:
             style = "bold red"
@@ -125,6 +130,15 @@ class InteractiveRenderer(MessageRenderer):
         if hasattr(self.console.file, "flush"):
             self.console.file.flush()
 
+    async def _handle_human_input_request(self, message: UIMessage):
+        """Handle a human input request in async mode."""
+        # This renderer is not currently used in practice, but if it were:
+        # We would need async input handling here
+        # For now, just render as a system message
+        self.console.print(f"[bold cyan]INPUT REQUESTED:[/bold cyan] {message.content}")
+        if hasattr(self.console.file, "flush"):
+            self.console.file.flush()
+
 
 class TUIRenderer(MessageRenderer):
     """Renderer for TUI mode that adds messages to the chat view."""
@@ -142,6 +156,11 @@ class TUIRenderer(MessageRenderer):
         if not self.tui_app:
             return
 
+        # Handle human input requests
+        if message.type == MessageType.HUMAN_INPUT_REQUEST:
+            await self._handle_human_input_request(message)
+            return
+
         # Extract group_id from message metadata (fixing the key name)
         group_id = message.metadata.get("message_group") if message.metadata else None
 
@@ -199,6 +218,48 @@ class TUIRenderer(MessageRenderer):
             # Default to system message
             self.tui_app.add_system_message(content_str, message_group=group_id)
 
+    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")
+            
+            # 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
+                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")
+                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]")
+            
+            # 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
+                if prompt_id:
+                    from code_puppy.messaging import provide_prompt_response
+                    provide_prompt_response(prompt_id, "")
+            except Exception:
+                pass  # Can't do anything more
+
 
 class SynchronousInteractiveRenderer:
     """
@@ -262,6 +323,11 @@ class SynchronousInteractiveRenderer:
 
     def _render_message(self, message: UIMessage):
         """Render a message using Rich console."""
+        # Handle human input requests
+        if message.type == MessageType.HUMAN_INPUT_REQUEST:
+            self._handle_human_input_request(message)
+            return
+
         # Convert message type to appropriate Rich styling
         if message.type == MessageType.ERROR:
             style = "bold red"
@@ -303,3 +369,31 @@ class SynchronousInteractiveRenderer:
         # This fixes the issue where messages don't appear until user input
         if hasattr(self.console.file, "flush"):
             self.console.file.flush()
+
+    def _handle_human_input_request(self, message: UIMessage):
+        """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]")
+            return
+
+        # Display the prompt
+        self.console.print(f"[bold cyan]{message.content}[/bold cyan]")
+        if hasattr(self.console.file, "flush"):
+            self.console.file.flush()
+
+        # Get user input
+        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, "")
+        except Exception as e:
+            self.console.print(f"[bold red]Error getting input: {e}[/bold red]")
+            provide_prompt_response(prompt_id, "")

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
+from .screens import HelpScreen, SettingsScreen, ToolsScreen, MCPInstallWizardScreen
 
 
 class CodePuppyTUI(App):
@@ -82,6 +82,7 @@ class CodePuppyTUI(App):
         Binding("ctrl+4", "show_tools", "Tools"),
         Binding("ctrl+5", "focus_input", "Focus Prompt"),
         Binding("ctrl+6", "focus_chat", "Focus Response"),
+        Binding("ctrl+t", "open_mcp_wizard", "MCP Install Wizard"),
     ]
 
     # Reactive variables for app state
@@ -629,6 +630,28 @@ class CodePuppyTUI(App):
 
         self.push_screen(SettingsScreen(), handle_settings_result)
 
+    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"))
+                
+                # 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")
+            elif (
+                result
+                and not result.get("success")
+                and "cancelled" not in result.get("message", "").lower()
+            ):
+                # 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:
         """Process the initial command provided when starting the TUI."""
         if self.initial_command:

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
+from textual.widgets import Static, Collapsible
 
 from ..models import ChatMessage, MessageType
 from .copy_button import CopyButton
@@ -30,14 +30,16 @@ class ChatView(VerticalScroll):
     }
 
     .user-message {
-        background: transparent;
+        background: $primary-darken-3;
         color: #ffffff;
         margin: 0 0 1 0;
         margin-top: 0;
-        padding: 0;
-        padding-top: 0;
+        padding: 1;
+        padding-top: 1;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
+        border-left: thick $accent;
+        text-style: bold;
     }
 
     .agent-message {
@@ -48,7 +50,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .system-message {
@@ -60,7 +62,7 @@ class ChatView(VerticalScroll):
         padding-top: 0;
         text-style: italic;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .error-message {
@@ -71,7 +73,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .agent_reasoning-message {
@@ -83,7 +85,7 @@ class ChatView(VerticalScroll):
         padding-top: 0;
         text-wrap: wrap;
         text-style: italic;
-        border: round $primary;
+        border: none;
     }
 
     .planned_next_steps-message {
@@ -95,7 +97,7 @@ class ChatView(VerticalScroll):
         padding-top: 0;
         text-wrap: wrap;
         text-style: italic;
-        border: round $primary;
+        border: none;
     }
 
     .agent_response-message {
@@ -106,7 +108,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .info-message {
@@ -117,7 +119,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .success-message {
@@ -128,7 +130,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .warning-message {
@@ -139,7 +141,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .tool_output-message {
@@ -150,7 +152,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .command_output-message {
@@ -161,7 +163,7 @@ class ChatView(VerticalScroll):
         padding: 0;
         padding-top: 0;
         text-wrap: wrap;
-        border: round $primary;
+        border: none;
     }
 
     .message-container {
@@ -339,8 +341,21 @@ class ChatView(VerticalScroll):
         css_class = f"{message.type.value}-message"
 
         if message.type == MessageType.USER:
-            content = f"{message.content}"
-            message_widget = Static(Text(content), classes=css_class)
+            # Add user indicator and make it stand out
+            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)
+            # Auto-scroll to bottom
+            self._schedule_scroll()
+            return
         elif message.type == MessageType.AGENT:
             prefix = "AGENT: "
             content = f"{message.content}"