codepp 0.0.437__py3-none-any.whl

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

@@ -0,0 +1,197 @@
+import os
+from typing import Iterable, Optional
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.history import FileHistory
+
+from code_puppy.config import get_global_model_name
+from code_puppy.model_factory import ModelFactory
+from code_puppy.model_switching import set_model_and_reload_agent
+
+
+def load_model_names():
+    """Load model names from the config that's fetched from the endpoint."""
+    models_config = ModelFactory.load_config()
+    return list(models_config.keys())
+
+
+def get_active_model():
+    """
+    Returns the active model from the config using get_model_name().
+    This ensures consistency across the codebase by always using the config value.
+    """
+    return get_global_model_name()
+
+
+def set_active_model(model_name: str):
+    """
+    Sets the active model name by updating the config (for persistence).
+    """
+    set_model_and_reload_agent(model_name)
+
+
+class ModelNameCompleter(Completer):
+    """
+    A completer that triggers on '/model' to show available models from models.json.
+    Only '/model' (not just '/') will trigger the dropdown.
+    """
+
+    def __init__(self, trigger: str = "/model"):
+        self.trigger = trigger
+        self.model_names = load_model_names()
+
+    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 /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
+
+        # 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:
+            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,
+                display=model_name,
+                display_meta=meta,
+            )
+
+
+def _find_matching_model(rest: str, model_names: list[str]) -> Optional[str]:
+    """
+    Find the best matching model for the given input.
+
+    Priority:
+    1. Exact match (case-insensitive)
+    2. Input starts with a model name (longest/most specific wins)
+    3. Model starts with input (prefix/completion match, longest wins)
+    """
+    rest_lower = rest.lower()
+
+    # First check for exact match
+    for model in model_names:
+        if rest_lower == model.lower():
+            return model
+
+    # Sort by length (longest first) so more specific matches win
+    sorted_models = sorted(model_names, key=len, reverse=True)
+
+    # Check if input starts with a model name (e.g. "gpt-5 tell me a joke")
+    for model in sorted_models:
+        model_lower = model.lower()
+        if rest_lower.startswith(model_lower) and (
+            len(rest_lower) == len(model_lower) or rest_lower[len(model_lower)] == " "
+        ):
+            return model
+
+    # Check for prefix/completion match (input is partial model name)
+    for model in sorted_models:
+        if model.lower().startswith(rest_lower):
+            return model
+
+    return None
+
+
+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()
+    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
+
+        # Find the best matching model
+        model = _find_matching_model(rest, model_names)
+        if model:
+            # Found a matching model - now extract it properly
+            set_active_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(cmd_and_model_pattern) :]
+                ).strip()
+                return new_text
+            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
+
+        # Find the best matching model
+        model = _find_matching_model(rest, model_names)
+        if model:
+            # Found a matching model - now extract it properly
+            set_active_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
+            # 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(cmd_and_model_pattern) :]
+                ).strip()
+                return new_text
+            return None
+
+    return None
+
+
+async def get_input_with_model_completion(
+    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(
+        completer=ModelNameCompleter(trigger),
+        history=history,
+        complete_while_typing=True,
+    )
+    text = await session.prompt_async(prompt_str)
+    possibly_stripped = update_model_in_input(text)
+    if possibly_stripped is not None:
+        return possibly_stripped
+    return text