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

code_puppy/command_line/mcp/wizard_utils.py

@@ -0,0 +1,259 @@
+"""
+MCP Interactive Wizard Utilities - Shared interactive installation wizard functions.
+
+Provides interactive functionality for installing and configuring MCP servers.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+from code_puppy.messaging import emit_info, emit_prompt
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+def run_interactive_install_wizard(manager, group_id: str) -> bool:
+    """
+    Run the interactive MCP server installation wizard.
+
+    Args:
+        manager: MCP manager instance
+        group_id: Message group ID for grouping related messages
+
+    Returns:
+        True if installation was successful, False otherwise
+    """
+    try:
+        # Show welcome message
+        emit_info("🚀 MCP Server Installation Wizard", message_group=group_id)
+        emit_info(
+            "This wizard will help you install pre-configured MCP servers",
+            message_group=group_id,
+        )
+        emit_info("", message_group=group_id)
+
+        # Let user select a server
+        selected_server = interactive_server_selection(group_id)
+        if not selected_server:
+            return False
+
+        # Get custom name
+        server_name = interactive_get_server_name(selected_server, group_id)
+        if not server_name:
+            return False
+
+        # Configure the server
+        return interactive_configure_server(
+            manager, selected_server, server_name, group_id
+        )
+
+    except ImportError:
+        emit_info("[red]Server catalog not available[/red]", message_group=group_id)
+        return False
+    except Exception as e:
+        logger.error(f"Error in interactive wizard: {e}")
+        emit_info(f"[red]Wizard error: {e}[/red]", message_group=group_id)
+        return False
+
+
+def interactive_server_selection(group_id: str):
+    """
+    Interactive server selection from catalog.
+
+    Returns selected server or None if cancelled.
+    """
+    # This is a simplified version - the full implementation would have
+    # category browsing, search, etc. For now, we'll just show popular servers
+    try:
+        from code_puppy.mcp.server_registry_catalog import catalog
+
+        servers = catalog.get_popular(10)
+        if not servers:
+            emit_info(
+                "[red]No servers available in catalog[/red]", message_group=group_id
+            )
+            return None
+
+        emit_info("Popular MCP Servers:", message_group=group_id)
+        for i, server in enumerate(servers, 1):
+            indicators = []
+            if server.verified:
+                indicators.append("✓")
+            if server.popular:
+                indicators.append("⭐")
+
+            indicator_str = ""
+            if indicators:
+                indicator_str = " " + "".join(indicators)
+
+            emit_info(
+                f"{i:2}. {server.display_name}{indicator_str}", message_group=group_id
+            )
+            emit_info(f"    {server.description[:80]}...", message_group=group_id)
+
+        choice = emit_prompt(
+            "Enter number (1-{}) or 'q' to quit: ".format(len(servers))
+        )
+
+        if choice.lower() == "q":
+            return None
+
+        try:
+            index = int(choice) - 1
+            if 0 <= index < len(servers):
+                return servers[index]
+            else:
+                emit_info("[red]Invalid selection[/red]", message_group=group_id)
+                return None
+        except ValueError:
+            emit_info("[red]Invalid input[/red]", message_group=group_id)
+            return None
+
+    except Exception as e:
+        logger.error(f"Error in server selection: {e}")
+        return None
+
+
+def interactive_get_server_name(selected_server, group_id: str) -> Optional[str]:
+    """
+    Get custom server name from user.
+
+    Returns server name or None if cancelled.
+    """
+    default_name = selected_server.name
+    server_name = emit_prompt(f"Enter name for this server [{default_name}]: ").strip()
+
+    if not server_name:
+        server_name = default_name
+
+    return server_name
+
+
+def interactive_configure_server(
+    manager, selected_server, server_name: str, group_id: str
+) -> bool:
+    """
+    Configure and install the selected server.
+
+    Returns True if successful, False otherwise.
+    """
+    try:
+        # Check if server already exists
+        from .utils import find_server_id_by_name
+
+        existing_server = find_server_id_by_name(manager, server_name)
+        if existing_server:
+            override = emit_prompt(
+                f"Server '{server_name}' already exists. Override? [y/N]: "
+            )
+            if not override.lower().startswith("y"):
+                emit_info("Installation cancelled", message_group=group_id)
+                return False
+
+        # For now, use defaults - a full implementation would collect env vars, etc.
+        # requirements = selected_server.get_requirements()  # TODO: Use for validation
+        env_vars = {}
+        cmd_args = {}
+
+        # Show confirmation
+        emit_info(f"Installing: {selected_server.display_name}", message_group=group_id)
+        emit_info(f"Name: {server_name}", message_group=group_id)
+
+        confirm = emit_prompt("Proceed with installation? [Y/n]: ")
+        if confirm.lower().startswith("n"):
+            emit_info("Installation cancelled", message_group=group_id)
+            return False
+
+        # Install the server (simplified version)
+        return install_server_from_catalog(
+            manager, selected_server, server_name, env_vars, cmd_args, group_id
+        )
+
+    except Exception as e:
+        logger.error(f"Error configuring server: {e}")
+        emit_info(f"[red]Configuration error: {e}[/red]", message_group=group_id)
+        return False
+
+
+def install_server_from_catalog(
+    manager,
+    selected_server,
+    server_name: str,
+    env_vars: Dict[str, Any],
+    cmd_args: Dict[str, Any],
+    group_id: str,
+) -> bool:
+    """
+    Install a server from the catalog with the given configuration.
+
+    Returns True if successful, False otherwise.
+    """
+    try:
+        import json
+        import os
+
+        from code_puppy.config import MCP_SERVERS_FILE
+        from code_puppy.mcp.managed_server import ServerConfig
+
+        # Create server configuration
+        config_dict = selected_server.get_config_template()
+
+        # Apply environment variables and command args
+        if env_vars:
+            config_dict.update(env_vars)
+        if cmd_args:
+            config_dict.update(cmd_args)
+
+        # Create ServerConfig
+        server_config = ServerConfig(
+            id=f"{server_name}_{hash(server_name)}",
+            name=server_name,
+            type=selected_server.type,
+            enabled=True,
+            config=config_dict,
+        )
+
+        # Register with manager
+        server_id = manager.register_server(server_config)
+
+        if not server_id:
+            emit_info(
+                "[red]Failed to register server with manager[/red]",
+                message_group=group_id,
+            )
+            return False
+
+        # Save to mcp_servers.json for persistence
+        if os.path.exists(MCP_SERVERS_FILE):
+            with open(MCP_SERVERS_FILE, "r") as f:
+                data = json.load(f)
+                servers = data.get("mcp_servers", {})
+        else:
+            servers = {}
+            data = {"mcp_servers": servers}
+
+        # Add new server
+        servers[server_name] = config_dict.copy()
+        servers[server_name]["type"] = selected_server.type
+
+        # Save back
+        os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
+        with open(MCP_SERVERS_FILE, "w") as f:
+            json.dump(data, f, indent=2)
+
+        emit_info(
+            f"[green]✓ Successfully installed server: {server_name}[/green]",
+            message_group=group_id,
+        )
+        emit_info(
+            "Use '/mcp start {}' to start the server".format(server_name),
+            message_group=group_id,
+        )
+
+        return True
+
+    except Exception as e:
+        logger.error(f"Error installing server: {e}")
+        emit_info(f"[red]Installation failed: {e}[/red]", message_group=group_id)
+        return False

code_puppy/command_line/model_picker_completion.py

@@ -70,9 +70,9 @@ class ModelNameCompleter(Completer):
 
 
 def update_model_in_input(text: str) -> Optional[str]:
-    # If input starts with /model and a model name, set model and strip it out
+    # If input starts with /model or /m and a model name, set model and strip it out
     content = text.strip()
-    
+
     # Check for /model command
     if content.startswith("/model"):
         rest = content[6:].strip()  # Remove '/model'
@@ -82,13 +82,30 @@ def update_model_in_input(text: str) -> Optional[str]:
                 # Remove /model from the input
                 idx = text.find("/model" + model)
                 if idx != -1:
-                    new_text = (text[:idx] + text[idx + len("/model" + model) :]).strip()
+                    new_text = (
+                        text[:idx] + text[idx + len("/model" + model) :]
+                    ).strip()
+                    return new_text
+
+    # Check for /m command
+    elif content.startswith("/m "):
+        rest = content[3:].strip()  # Remove '/m '
+        for model in load_model_names():
+            if rest == model:
+                set_active_model(model)
+                # Remove /m from the input
+                idx = text.find("/m " + model)
+                if idx != -1:
+                    new_text = (text[:idx] + text[idx + len("/m " + model) :]).strip()
                     return new_text
+
     return None
 
 
 async def get_input_with_model_completion(
-    prompt_str: str = ">>> ", trigger: str = "/model", history_file: Optional[str] = None
+    prompt_str: str = ">>> ",
+    trigger: str = "/model",
+    history_file: Optional[str] = None,
 ) -> str:
     history = FileHistory(os.path.expanduser(history_file)) if history_file else None
     session = PromptSession(

code_puppy/command_line/prompt_toolkit_completion.py

@@ -136,8 +136,15 @@ class CDCompleter(Completer):
 
 
 def get_prompt_with_active_model(base: str = ">>> "):
+    from code_puppy.agents.agent_manager import get_current_agent_config
+
     puppy = get_puppy_name()
     model = get_active_model() or "(default)"
+
+    # Get current agent information
+    current_agent = get_current_agent_config()
+    agent_display = current_agent.display_name if current_agent else "code-puppy"
+
     cwd = os.getcwd()
     home = os.path.expanduser("~")
     if cwd.startswith(home):
@@ -149,6 +156,7 @@ def get_prompt_with_active_model(base: str = ">>> "):
             ("bold", "🐶 "),
             ("class:puppy", f"{puppy}"),
             ("", " "),
+            ("class:agent", f"[{agent_display}] "),
             ("class:model", "[" + str(model) + "] "),
             ("class:cwd", "(" + str(cwd_display) + ") "),
             ("class:arrow", str(base)),
@@ -213,6 +221,7 @@ async def get_input_with_combined_completion(
             # tagging tokens in `FormattedText`. See prompt_toolkit docs.
             "puppy": "bold magenta",
             "owner": "bold white",
+            "agent": "bold blue",
             "model": "bold cyan",
             "cwd": "bold green",
             "arrow": "bold yellow",

code_puppy/main.py

@@ -11,7 +11,7 @@ from rich.markdown import CodeBlock, Markdown
 from rich.syntax import Syntax
 from rich.text import Text
 
-from code_puppy import __version__, callbacks, plugins, state_management
+from code_puppy import __version__, callbacks, plugins
 from code_puppy.agent import get_custom_usage_limits
 from code_puppy.agents.runtime_manager import get_runtime_agent_manager
 from code_puppy.command_line.prompt_toolkit_completion import (
@@ -29,7 +29,7 @@ from code_puppy.message_history_processor import (
     message_history_accumulator,
     prune_interrupted_tool_calls,
 )
-from code_puppy.state_management import is_tui_mode, set_tui_mode, set_message_history
+from code_puppy.state_management import is_tui_mode, set_message_history, set_tui_mode
 from code_puppy.tools.common import console
 from code_puppy.version_checker import default_version_mismatch_behavior
 
@@ -263,8 +263,8 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
         from code_puppy.messaging import emit_warning
 
         emit_warning(f"MOTD error: {e}")
-    from code_puppy.messaging import emit_info
     from code_puppy.agents.runtime_manager import get_runtime_agent_manager
+    from code_puppy.messaging import emit_info
 
     emit_info("[bold cyan]Initializing agent...[/bold cyan]")
     # Initialize the runtime agent manager
@@ -352,8 +352,8 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             emit_warning("Falling back to basic input without tab completion")
 
     while True:
-        from code_puppy.messaging import emit_info
         from code_puppy.agents.agent_manager import get_current_agent_config
+        from code_puppy.messaging import emit_info
 
         # Get the custom prompt from the current agent, or use default
         current_agent = get_current_agent_config()
@@ -426,15 +426,17 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
                 # Create a task that mimics TUI behavior - avoid signal handler conflicts
                 current_task = None
-                signal_handled = False  # Prevent multiple signal handler calls (reset per task)
-                
+                signal_handled = (
+                    False  # Prevent multiple signal handler calls (reset per task)
+                )
+
                 async def run_task():
                     # Use the simpler run() method instead of run_with_mcp() to avoid signal handler
                     agent = agent_manager.get_agent()
                     async with agent:
                         return await agent.run(
                             task,
-                            message_history=get_message_history(), 
+                            message_history=get_message_history(),
                             usage_limits=get_custom_usage_limits(),
                         )
 
@@ -444,27 +446,29 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                     if signal_handled:
                         return
                     signal_handled = True
-                    
-                    from code_puppy.tools.command_runner import kill_all_running_shell_processes
-                    
+
+                    from code_puppy.tools.command_runner import (
+                        kill_all_running_shell_processes,
+                    )
+
                     killed = kill_all_running_shell_processes()
                     if killed:
                         emit_warning(f"🔥 Cancelled {killed} running shell process(es)")
                         # Don't cancel the agent task - let it continue processing
                         # Shell processes killed, but agent continues running
                     else:
-                        # Only cancel the agent task if NO processes were killed  
+                        # Only cancel the agent task if NO processes were killed
                         if current_task and not current_task.done():
                             current_task.cancel()
                             emit_warning("⚠️  Processing cancelled by user")
 
                 # Set up proper signal handling to override asyncio's default behavior
                 import signal
-                
+
                 def signal_handler(sig, frame):
                     """Handle Ctrl+C by killing processes and cancelling the current task"""
                     handle_keyboard_interrupt()
-                
+
                 # Replace asyncio's SIGINT handler with our own
                 original_handler = signal.signal(signal.SIGINT, signal_handler)
 
@@ -483,7 +487,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                     result = None
                 finally:
                     # Restore original signal handler
-                    if 'original_handler' in locals():
+                    if "original_handler" in locals():
                         signal.signal(signal.SIGINT, original_handler)
                     set_message_history(
                         prune_interrupted_tool_calls(get_message_history())
@@ -559,12 +563,12 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
     try:
         # Get agent through runtime manager and use its run_with_mcp method
         agent_manager = get_runtime_agent_manager()
-        
+
         from code_puppy.messaging.spinner import ConsoleSpinner
+
         with ConsoleSpinner(console=message_renderer.console):
             response = await agent_manager.run_with_mcp(
-                prompt, 
-                usage_limits=get_custom_usage_limits()
+                prompt, usage_limits=get_custom_usage_limits()
             )
 
         agent_response = response.output
@@ -574,9 +578,11 @@ async def execute_single_prompt(prompt: str, message_renderer) -> None:
 
     except asyncio.CancelledError:
         from code_puppy.messaging import emit_warning
+
         emit_warning("Execution cancelled by user")
     except Exception as e:
         from code_puppy.messaging import emit_error
+
         emit_error(f"Error executing prompt: {str(e)}")
 
 

code_puppy/mcp/__init__.py

@@ -1,23 +1,49 @@
-"""MCP (Model Context Protocol) management system for Code Puppy."""
+"""MCP (Model Context Protocol) management system for Code Puppy.
 
+Note: Be careful not to create circular imports with config_wizard.py. 
+config_wizard.py imports ServerConfig and get_mcp_manager directly from 
+.manager to avoid circular dependencies with this package __init__.py
+"""
+
+from .circuit_breaker import CircuitBreaker, CircuitOpenError, CircuitState
+from .config_wizard import MCPConfigWizard, run_add_wizard
+from .dashboard import MCPDashboard
+from .error_isolation import (
+    ErrorCategory,
+    ErrorStats,
+    MCPErrorIsolator,
+    QuarantinedServerError,
+    get_error_isolator,
+)
 from .managed_server import ManagedMCPServer, ServerConfig, ServerState
-from .status_tracker import ServerStatusTracker, Event
 from .manager import MCPManager, ServerInfo, get_mcp_manager
 from .registry import ServerRegistry
-from .error_isolation import MCPErrorIsolator, ErrorStats, ErrorCategory, QuarantinedServerError, get_error_isolator
-from .circuit_breaker import CircuitBreaker, CircuitState, CircuitOpenError
 from .retry_manager import RetryManager, RetryStats, get_retry_manager, retry_mcp_call
-from .dashboard import MCPDashboard
-from .config_wizard import MCPConfigWizard, run_add_wizard
+from .status_tracker import Event, ServerStatusTracker
 
 __all__ = [
-    'ManagedMCPServer', 'ServerConfig', 'ServerState', 
-    'ServerStatusTracker', 'Event',
-    'MCPManager', 'ServerInfo', 'get_mcp_manager',
-    'ServerRegistry',
-    'MCPErrorIsolator', 'ErrorStats', 'ErrorCategory', 'QuarantinedServerError', 'get_error_isolator',
-    'CircuitBreaker', 'CircuitState', 'CircuitOpenError',
-    'RetryManager', 'RetryStats', 'get_retry_manager', 'retry_mcp_call',
-    'MCPDashboard',
-    'MCPConfigWizard', 'run_add_wizard'
-]
+    "ManagedMCPServer",
+    "ServerConfig",
+    "ServerState",
+    "ServerStatusTracker",
+    "Event",
+    "MCPManager",
+    "ServerInfo",
+    "get_mcp_manager",
+    "ServerRegistry",
+    "MCPErrorIsolator",
+    "ErrorStats",
+    "ErrorCategory",
+    "QuarantinedServerError",
+    "get_error_isolator",
+    "CircuitBreaker",
+    "CircuitState",
+    "CircuitOpenError",
+    "RetryManager",
+    "RetryStats",
+    "get_retry_manager",
+    "retry_mcp_call",
+    "MCPDashboard",
+    "MCPConfigWizard",
+    "run_add_wizard",
+]