code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/command_line/mcp/stop_command.py

@@ -5,7 +5,9 @@ MCP Stop Command - Stops a specific MCP server.
 import logging
 from typing import List, Optional
 
-from code_puppy.messaging import emit_info
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info
 
 from ...agents import get_current_agent
 from .base import MCPCommandBase
@@ -35,7 +37,7 @@ class StopCommand(MCPCommandBase):
 
         if not args:
             emit_info(
-                "[yellow]Usage: /mcp stop <server_name>[/yellow]",
+                Text.from_markup("[yellow]Usage: /mcp stop <server_name>[/yellow]"),
                 message_group=group_id,
             )
             return
@@ -60,8 +62,10 @@ class StopCommand(MCPCommandBase):
                 try:
                     agent = get_current_agent()
                     agent.reload_code_generation_agent()
+                    # Update MCP tool cache immediately so token counts reflect the change
+                    agent.update_mcp_tool_cache_sync()
                     emit_info(
-                        "[dim]Agent reloaded with updated servers[/dim]",
+                        "Agent reloaded with updated servers",
                         message_group=group_id,
                     )
                 except Exception as e:
@@ -73,4 +77,4 @@ class StopCommand(MCPCommandBase):
 
         except Exception as e:
             logger.error(f"Error stopping server '{server_name}': {e}")
-            emit_info(f"[red]Failed to stop server: {e}[/red]", message_group=group_id)
+            emit_error(f"Failed to stop server: {e}", message_group=group_id)

code_puppy/command_line/mcp/test_command.py

@@ -5,7 +5,7 @@ MCP Test Command - Tests connectivity to a specific MCP server.
 import logging
 from typing import List, Optional
 
-from code_puppy.messaging import emit_info
+from code_puppy.messaging import emit_error, emit_info
 
 from .base import MCPCommandBase
 from .utils import find_server_id_by_name, suggest_similar_servers
@@ -104,4 +104,4 @@ class TestCommand(MCPCommandBase):
 
         except Exception as e:
             logger.error(f"Error testing server '{server_name}': {e}")
-            emit_info(f"[red]Error testing server: {e}[/red]", message_group=group_id)
+            emit_error(f"Error testing server: {e}", message_group=group_id)

code_puppy/command_line/mcp/wizard_utils.py

@@ -7,7 +7,9 @@ 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
+from rich.text import Text
+
+from code_puppy.messaging import emit_error, emit_info, emit_prompt
 
 # Configure logging
 logger = logging.getLogger(__name__)
@@ -51,7 +53,7 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
         required_env_vars = selected_server.get_environment_vars()
         if required_env_vars:
             emit_info(
-                "\n[yellow]Required Environment Variables:[/yellow]",
+                Text.from_markup("\n[yellow]Required Environment Variables:[/yellow]"),
                 message_group=group_id,
             )
             for var in required_env_vars:
@@ -61,7 +63,8 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
                 current_value = os.environ.get(var, "")
                 if current_value:
                     emit_info(
-                        f"  {var}: [green]Already set[/green]", message_group=group_id
+                        Text.from_markup(f"  {var}: [green]Already set[/green]"),
+                        message_group=group_id,
                     )
                     env_vars[var] = current_value
                 else:
@@ -73,7 +76,8 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
         required_cmd_args = selected_server.get_command_line_args()
         if required_cmd_args:
             emit_info(
-                "\n[yellow]Command Line Arguments:[/yellow]", message_group=group_id
+                Text.from_markup("\n[yellow]Command Line Arguments:[/yellow]"),
+                message_group=group_id,
             )
             for arg_config in required_cmd_args:
                 name = arg_config.get("name", "")
@@ -101,11 +105,11 @@ def run_interactive_install_wizard(manager, group_id: str) -> bool:
         )
 
     except ImportError:
-        emit_info("[red]Server catalog not available[/red]", message_group=group_id)
+        emit_error("Server catalog not available", 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)
+        emit_error(f"Wizard error: {e}", message_group=group_id)
         return False
 
 
@@ -122,9 +126,7 @@ def interactive_server_selection(group_id: str):
 
         servers = catalog.get_popular(10)
         if not servers:
-            emit_info(
-                "[red]No servers available in catalog[/red]", message_group=group_id
-            )
+            emit_info("No servers available in catalog", message_group=group_id)
             return None
 
         emit_info("Popular MCP Servers:", message_group=group_id)
@@ -156,10 +158,10 @@ def interactive_server_selection(group_id: str):
             if 0 <= index < len(servers):
                 return servers[index]
             else:
-                emit_info("[red]Invalid selection[/red]", message_group=group_id)
+                emit_error("Invalid selection", message_group=group_id)
                 return None
         except ValueError:
-            emit_info("[red]Invalid input[/red]", message_group=group_id)
+            emit_error("Invalid input", message_group=group_id)
             return None
 
     except Exception as e:
@@ -215,7 +217,7 @@ def interactive_configure_server(
         if env_vars:
             emit_info("Environment Variables:", message_group=group_id)
             for var, value in env_vars.items():
-                emit_info(f"  {var}: [hidden]{value}[/hidden]", message_group=group_id)
+                emit_info(f"  {var}: ***", message_group=group_id)
 
         if cmd_args:
             emit_info("Command Line Arguments:", message_group=group_id)
@@ -234,7 +236,7 @@ def interactive_configure_server(
 
     except Exception as e:
         logger.error(f"Error configuring server: {e}")
-        emit_info(f"[red]Configuration error: {e}[/red]", message_group=group_id)
+        emit_error(f"Configuration error: {e}", message_group=group_id)
         return False
 
 
@@ -288,7 +290,7 @@ def install_server_from_catalog(
 
         if not server_id:
             emit_info(
-                "[red]Failed to register server with manager[/red]",
+                "Failed to register server with manager",
                 message_group=group_id,
             )
             return False
@@ -314,7 +316,9 @@ def install_server_from_catalog(
             json.dump(data, f, indent=2)
 
         emit_info(
-            f"[green]✓ Successfully installed server: {server_name}[/green]",
+            Text.from_markup(
+                f"[green]✓ Successfully installed server: {server_name}[/green]"
+            ),
             message_group=group_id,
         )
         emit_info(
@@ -326,5 +330,5 @@ def install_server_from_catalog(
 
     except Exception as e:
         logger.error(f"Error installing server: {e}")
-        emit_info(f"[red]Installation failed: {e}[/red]", message_group=group_id)
+        emit_error(f"Installation failed: {e}", message_group=group_id)
         return False

code_puppy/command_line/mcp_completion.py

@@ -0,0 +1,174 @@
+import logging
+from typing import Iterable
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+def load_server_names():
+    """Load server names from the MCP manager."""
+    try:
+        from code_puppy.mcp_.manager import MCPManager
+
+        manager = MCPManager()
+        servers = manager.list_servers()
+        return [server.name for server in servers]
+    except Exception as e:
+        logger.debug(f"Could not load server names: {e}")
+        return []
+
+
+class MCPCompleter(Completer):
+    """
+    A completer that triggers on '/mcp' to show available MCP subcommands
+    and server names where appropriate.
+    """
+
+    def __init__(self, trigger: str = "/mcp"):
+        self.trigger = trigger
+
+        # Define all available MCP subcommands
+        # Subcommands that take server names as arguments
+        self.server_subcommands = {
+            "start": "Start a specific MCP server",
+            "stop": "Stop a specific MCP server",
+            "restart": "Restart a specific MCP server",
+            "status": "Show status of a specific MCP server",
+            "logs": "Show logs for a specific MCP server",
+            "edit": "Edit an existing MCP server config",
+            "remove": "Remove an MCP server",
+        }
+
+        # Subcommands that don't take server names
+        self.general_subcommands = {
+            "list": "List all registered MCP servers",
+            "start-all": "Start all MCP servers",
+            "stop-all": "Stop all MCP servers",
+            "test": "Test MCP server connection",
+            "add": "Add a new MCP server",
+            "install": "Install MCP servers from a list",
+            "search": "Search for available MCP servers",
+            "help": "Show help for MCP commands",
+        }
+
+        # All subcommands combined for completion when no subcommand is typed yet
+        self.all_subcommands = {**self.server_subcommands, **self.general_subcommands}
+
+        # Cache server names to avoid repeated lookups
+        self._server_names_cache = None
+        self._cache_timestamp = None
+
+    def _get_server_names(self):
+        """Get server names with caching."""
+        import time
+
+        # Cache for 30 seconds to avoid repeated manager calls
+        current_time = time.time()
+        if (
+            self._server_names_cache is None
+            or self._cache_timestamp is None
+            or current_time - self._cache_timestamp > 30
+        ):
+            self._server_names_cache = load_server_names()
+            self._cache_timestamp = current_time
+
+        return self._server_names_cache or []
+
+    def get_completions(
+        self, document: Document, complete_event
+    ) -> Iterable[Completion]:
+        text = document.text
+        cursor_position = document.cursor_position
+        text_before_cursor = text[:cursor_position]
+
+        # Only trigger if /mcp is at the very beginning of the line
+        stripped_text = text_before_cursor.lstrip()
+        if not stripped_text.startswith(self.trigger):
+            return
+
+        # Find where /mcp actually starts (after any leading whitespace)
+        mcp_pos = text_before_cursor.find(self.trigger)
+        mcp_end = mcp_pos + len(self.trigger)
+
+        # Require a space after /mcp before showing completions
+        if mcp_end >= len(text_before_cursor) or text_before_cursor[mcp_end] != " ":
+            return
+
+        # Extract everything after /mcp (and after the space)
+        after_mcp = text_before_cursor[mcp_end + 1 :].strip()
+
+        # If nothing after /mcp, show all available subcommands
+        if not after_mcp:
+            for subcommand, description in sorted(self.all_subcommands.items()):
+                yield Completion(
+                    subcommand,
+                    start_position=0,
+                    display=subcommand,
+                    display_meta=description,
+                )
+            return
+
+        # Parse what's been typed after /mcp
+        # Split by space but be careful with what we're currently typing
+        parts = after_mcp.split()
+
+        # Priority: Check for server name completion first when appropriate
+        # This handles cases like '/mcp start ' where the space indicates ready for server name
+        if len(parts) >= 1:
+            subcommand = parts[0].lower()
+
+            # Only complete server names for specific subcommands
+            if subcommand in self.server_subcommands:
+                # Case 1: Exactly the subcommand followed by a space (ready for server name)
+                if len(parts) == 1 and text.endswith(" "):
+                    partial_server = ""
+                    start_position = 0
+
+                    server_names = self._get_server_names()
+                    for server_name in sorted(server_names):
+                        yield Completion(
+                            server_name,
+                            start_position=start_position,
+                            display=server_name,
+                            display_meta="MCP Server",
+                        )
+                    return
+
+                # Case 2: Subcommand + partial server name (require space after subcommand)
+                elif len(parts) == 2 and cursor_position > (
+                    mcp_end + 1 + len(subcommand) + 1
+                ):
+                    partial_server = parts[1]
+                    start_position = -(len(partial_server))
+
+                    server_names = self._get_server_names()
+                    for server_name in sorted(server_names):
+                        if server_name.lower().startswith(partial_server.lower()):
+                            yield Completion(
+                                server_name,
+                                start_position=start_position,
+                                display=server_name,
+                                display_meta="MCP Server",
+                            )
+                    return
+
+        # If we only have one part and haven't returned above, show subcommand completions
+        # This includes cases like '/mcp start' where they might want 'start-all'
+        # But NOT when there's a space after the subcommand (which indicates they want arguments)
+        if len(parts) == 1 and not text.endswith(" "):
+            partial_subcommand = parts[0]
+            for subcommand, description in sorted(self.all_subcommands.items()):
+                if subcommand.startswith(partial_subcommand):
+                    yield Completion(
+                        subcommand,
+                        start_position=-(len(partial_subcommand)),
+                        display=subcommand,
+                        display_meta=description,
+                    )
+            return
+
+        # For general subcommands, we don't provide argument completion
+        # They may have their own specific completions in the future

code_puppy/command_line/model_picker_completion.py

@@ -28,6 +28,8 @@ def set_active_model(model_name: str):
     """
     Sets the active model name by updating the config (for persistence).
     """
+    from code_puppy.messaging import emit_info, emit_warning
+
     set_model_name(model_name)
     # Reload the currently active agent so the new model takes effect immediately
     try:
@@ -42,9 +44,9 @@ def set_active_model(model_name: str):
                 # Non-fatal, continue to reload
                 ...
         current_agent.reload_code_generation_agent()
-    except Exception:
-        # Swallow errors to avoid breaking the prompt flow; model persists for next run
-        pass
+        emit_info("Active agent reloaded")
+    except Exception as e:
+        emit_warning(f"Model changed but agent reload failed: {e}")
 
 
 class ModelNameCompleter(Completer):
@@ -63,13 +65,31 @@ class ModelNameCompleter(Completer):
         text = document.text
         cursor_position = document.cursor_position
         text_before_cursor = text[:cursor_position]
-        if self.trigger not in text_before_cursor:
+
+        # Only trigger if /model is at the very beginning of the line and has a space after it
+        stripped_text = text_before_cursor.lstrip()
+        if not stripped_text.startswith(self.trigger + " "):
             return
-        symbol_pos = text_before_cursor.rfind(self.trigger)
-        text_after_trigger = text_before_cursor[symbol_pos + len(self.trigger) :]
+
+        # Find where /model actually starts (after any leading whitespace)
+        symbol_pos = text_before_cursor.find(self.trigger)
+        text_after_trigger = text_before_cursor[
+            symbol_pos + len(self.trigger) + 1 :
+        ].lstrip()
         start_position = -(len(text_after_trigger))
+
+        # Filter model names based on what's typed after /model (case-insensitive)
         for model_name in self.model_names:
-            meta = "Model (selected)" if model_name == get_active_model() else "Model"
+            if text_after_trigger and not model_name.lower().startswith(
+                text_after_trigger.lower()
+            ):
+                continue  # Skip models that don't match the typed text
+
+            meta = (
+                "Model (selected)"
+                if model_name.lower() == get_active_model().lower()
+                else "Model"
+            )
             yield Completion(
                 model_name,
                 start_position=start_position,
@@ -81,32 +101,62 @@ class ModelNameCompleter(Completer):
 def update_model_in_input(text: str) -> Optional[str]:
     # 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'
-        for model in load_model_names():
-            if rest == model:
+    model_names = load_model_names()
+
+    # Check for /model command (require space after /model, case-insensitive)
+    if content.lower().startswith("/model "):
+        # Find the actual /model command (case-insensitive)
+        model_cmd = content.split(" ", 1)[0]  # Get the command part
+        rest = content[len(model_cmd) :].strip()  # Remove the actual command
+
+        # Look for a model name at the start of rest (case-insensitive)
+        for model in model_names:
+            if rest.lower().startswith(model.lower()):
+                # Found a matching model - now extract it properly
                 set_active_model(model)
-                # Remove /model from the input
-                idx = text.find("/model" + model)
+
+                # Find the actual model name in the original text (preserving case)
+                # We need to find where the model ends in the original rest string
+                model_end_idx = len(model)
+
+                # Build the full command+model part to remove
+                cmd_and_model_pattern = model_cmd + " " + rest[:model_end_idx]
+                idx = text.find(cmd_and_model_pattern)
                 if idx != -1:
                     new_text = (
-                        text[:idx] + text[idx + len("/model" + model) :]
+                        text[:idx] + text[idx + len(cmd_and_model_pattern) :]
                     ).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:
+                return None
+
+    # Check for /m command (case-insensitive)
+    elif content.lower().startswith("/m ") and not content.lower().startswith(
+        "/model "
+    ):
+        # Find the actual /m command (case-insensitive)
+        m_cmd = content.split(" ", 1)[0]  # Get the command part
+        rest = content[len(m_cmd) :].strip()  # Remove the actual command
+
+        # Look for a model name at the start of rest (case-insensitive)
+        for model in model_names:
+            if rest.lower().startswith(model.lower()):
+                # Found a matching model - now extract it properly
                 set_active_model(model)
-                # Remove /m from the input
-                idx = text.find("/m " + model)
+
+                # Find the actual model name in the original text (preserving case)
+                # We need to find where the model ends in the original rest string
+                model_end_idx = len(model)
+
+                # Build the full command+model part to remove
+                # Handle space variations in the original text
+                cmd_and_model_pattern = m_cmd + " " + rest[:model_end_idx]
+                idx = text.find(cmd_and_model_pattern)
                 if idx != -1:
-                    new_text = (text[:idx] + text[idx + len("/m " + model) :]).strip()
+                    new_text = (
+                        text[:idx] + text[idx + len(cmd_and_model_pattern) :]
+                    ).strip()
                     return new_text
+                return None
 
     return None