codepp 0.0.437__py3-none-any.whl

code_puppy/command_line/file_path_completion.py

@@ -0,0 +1,73 @@
+import glob
+import os
+from typing import Iterable
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+
+class FilePathCompleter(Completer):
+    """A simple file path completer that works with a trigger symbol."""
+
+    def __init__(self, symbol: str = "@"):
+        self.symbol = symbol
+
+    def get_completions(
+        self, document: Document, complete_event
+    ) -> Iterable[Completion]:
+        text = document.text
+        cursor_position = document.cursor_position
+        text_before_cursor = text[:cursor_position]
+        if self.symbol not in text_before_cursor:
+            return
+        symbol_pos = text_before_cursor.rfind(self.symbol)
+        text_after_symbol = text_before_cursor[symbol_pos + len(self.symbol) :]
+        start_position = -(len(text_after_symbol))
+        try:
+            pattern = text_after_symbol + "*"
+            if not pattern.strip("*") or pattern.strip("*").endswith("/"):
+                base_path = pattern.strip("*")
+                if not base_path:
+                    base_path = "."
+                if base_path.startswith("~"):
+                    base_path = os.path.expanduser(base_path)
+                if os.path.isdir(base_path):
+                    paths = [
+                        os.path.join(base_path, f)
+                        for f in os.listdir(base_path)
+                        if not f.startswith(".") or text_after_symbol.endswith(".")
+                    ]
+                else:
+                    paths = []
+            else:
+                paths = glob.glob(pattern)
+                if not pattern.startswith(".") and not pattern.startswith("*/."):
+                    paths = [
+                        p for p in paths if not os.path.basename(p).startswith(".")
+                    ]
+            paths.sort()
+            for path in paths:
+                is_dir = os.path.isdir(path)
+                display = os.path.basename(path)
+                if os.path.isabs(path):
+                    display_path = path
+                else:
+                    if text_after_symbol.startswith("/"):
+                        display_path = os.path.abspath(path)
+                    elif text_after_symbol.startswith("~"):
+                        home = os.path.expanduser("~")
+                        if path.startswith(home):
+                            display_path = "~" + path[len(home) :]
+                        else:
+                            display_path = path
+                    else:
+                        display_path = path
+                display_meta = "Directory" if is_dir else "File"
+                yield Completion(
+                    display_path,
+                    start_position=start_position,
+                    display=display,
+                    display_meta=display_meta,
+                )
+        except (PermissionError, FileNotFoundError, OSError):
+            pass

code_puppy/command_line/load_context_completion.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+
+from prompt_toolkit.completion import Completer, Completion
+
+from code_puppy.config import CONFIG_DIR
+
+
+class LoadContextCompleter(Completer):
+    def __init__(self, trigger: str = "/load_context"):
+        self.trigger = trigger
+
+    def get_completions(self, document, complete_event):
+        cursor_position = document.cursor_position
+        text_before_cursor = document.text_before_cursor
+        stripped_text_for_trigger_check = text_before_cursor.lstrip()
+
+        # If user types just /load_context (no space), suggest adding a space
+        if stripped_text_for_trigger_check == self.trigger:
+            yield Completion(
+                self.trigger + " ",
+                start_position=-len(self.trigger),
+                display=self.trigger + " ",
+                display_meta="load saved context",
+            )
+            return
+
+        # Require a space after /load_context before showing completions (consistency with other completers)
+        if not stripped_text_for_trigger_check.startswith(self.trigger + " "):
+            return
+
+        # Extract the session name after /load_context and space (up to cursor)
+        actual_trigger_pos = text_before_cursor.find(self.trigger)
+        trigger_end = actual_trigger_pos + len(self.trigger) + 1  # +1 for the space
+        session_filter = text_before_cursor[trigger_end:cursor_position].lstrip()
+        start_position = -(len(session_filter))
+
+        # Get available context files
+        try:
+            contexts_dir = Path(CONFIG_DIR) / "contexts"
+            if contexts_dir.exists():
+                for pkl_file in contexts_dir.glob("*.pkl"):
+                    session_name = pkl_file.stem  # removes .pkl extension
+                    if session_name.startswith(session_filter):
+                        yield Completion(
+                            session_name,
+                            start_position=start_position,
+                            display=session_name,
+                            display_meta="saved context session",
+                        )
+        except Exception:
+            # Silently ignore errors (e.g., permission issues, non-existent dir)
+            pass

code_puppy/command_line/mcp/__init__.py

@@ -0,0 +1,10 @@
+"""
+MCP Command Line Interface - Namespace package for MCP server management commands.
+
+This package provides a modular command interface for managing MCP servers.
+Each command is implemented in its own module for better maintainability.
+"""
+
+from .handler import MCPCommandHandler
+
+__all__ = ["MCPCommandHandler"]

code_puppy/command_line/mcp/base.py

@@ -0,0 +1,32 @@
+"""
+MCP Command Base Classes - Shared functionality for MCP command handlers.
+
+Provides base classes and common utilities used across all MCP command modules.
+"""
+
+import logging
+
+from code_puppy.mcp_.manager import get_mcp_manager
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+class MCPCommandBase:
+    """
+    Base class for MCP command handlers.
+
+    Provides common functionality like console access and MCP manager access
+    that all command handlers need.
+    """
+
+    def __init__(self):
+        """Initialize the base command handler."""
+        self.manager = get_mcp_manager()
+        logger.debug(f"Initialized {self.__class__.__name__}")
+
+    def generate_group_id(self) -> str:
+        """Generate a unique group ID for message grouping."""
+        import uuid
+
+        return str(uuid.uuid4())

code_puppy/command_line/mcp/catalog_server_installer.py

@@ -0,0 +1,175 @@
+"""Catalog MCP server installation logic.
+
+Handles prompting users for configuration and installing
+MCP servers from the catalog.
+"""
+
+import os
+from typing import Dict, Optional
+
+from code_puppy.command_line.utils import safe_input
+from code_puppy.messaging import emit_info, emit_success, emit_warning
+
+# Helpful hints for common environment variables
+ENV_VAR_HINTS = {
+    "GITHUB_TOKEN": "💡 Get from https://github.com/settings/tokens",
+    "GITLAB_TOKEN": "💡 Get from GitLab > Preferences > Access Tokens",
+    "SLACK_TOKEN": "💡 Get from https://api.slack.com/apps",
+    "DISCORD_TOKEN": "💡 Get from Discord Developer Portal",
+    "OPENAI_API_KEY": "💡 Get from https://platform.openai.com/api-keys",
+    "ANTHROPIC_API_KEY": "💡 Get from https://console.anthropic.com/",
+    "GOOGLE_CLIENT_ID": "💡 Get from Google Cloud Console",
+    "GOOGLE_CLIENT_SECRET": "💡 Get from Google Cloud Console",
+    "NOTION_TOKEN": "💡 Get from https://www.notion.so/my-integrations",
+    "CONFLUENCE_TOKEN": "💡 Get from Atlassian API tokens",
+    "JIRA_TOKEN": "💡 Get from Atlassian API tokens",
+    "GRAFANA_TOKEN": "💡 Get from Grafana > Configuration > API Keys",
+    "DATABASE_URL": "💡 Format: postgresql://user:pass@host:5432/db",
+}
+
+
+def get_env_var_hint(env_var: str) -> str:
+    """Get a helpful hint for common environment variables."""
+    return ENV_VAR_HINTS.get(env_var, "")
+
+
+def prompt_for_server_config(manager, server) -> Optional[Dict]:
+    """Prompt user for server configuration (env vars and cmd args).
+
+    Args:
+        manager: MCP manager instance
+        server: Server template from catalog
+
+    Returns:
+        Dict with 'name', 'env_vars', 'cmd_args' if successful, None if cancelled
+    """
+    from code_puppy.config import set_config_value
+
+    from .utils import find_server_id_by_name
+
+    emit_info(f"\n📦 Installing: {server.display_name}\n")
+    emit_info(f"   {server.description}\n")
+
+    # Get custom name
+    default_name = server.name
+    try:
+        name_input = safe_input(f"  Server name [{default_name}]: ")
+        server_name = name_input if name_input else default_name
+    except (KeyboardInterrupt, EOFError):
+        emit_info("")
+        emit_warning("Installation cancelled")
+        return None
+
+    # Check if server already exists
+    existing = find_server_id_by_name(manager, server_name)
+    if existing:
+        try:
+            override = safe_input(f"  Server '{server_name}' exists. Override? [y/N]: ")
+            if not override.lower().startswith("y"):
+                emit_warning("Installation cancelled")
+                return None
+        except (KeyboardInterrupt, EOFError):
+            emit_info("")
+            emit_warning("Installation cancelled")
+            return None
+
+    env_vars = {}
+    cmd_args = {}
+
+    # Collect environment variables
+    required_env_vars = server.get_environment_vars()
+    if required_env_vars:
+        emit_info("\n  🔑 Environment Variables:")
+        for var in required_env_vars:
+            current_value = os.environ.get(var, "")
+            if current_value:
+                emit_info(f"     ✓ {var}: Already set")
+                env_vars[var] = current_value
+            else:
+                try:
+                    hint = get_env_var_hint(var)
+                    if hint:
+                        emit_info(f"     {hint}")
+                    value = safe_input(f"     Enter {var}: ")
+                    if value:
+                        env_vars[var] = value
+                        # Save to config for future use
+                        set_config_value(var, value)
+                        os.environ[var] = value
+                except (KeyboardInterrupt, EOFError):
+                    emit_info("")
+                    emit_warning("Installation cancelled")
+                    return None
+
+    # Collect command line arguments
+    required_cmd_args = server.get_command_line_args()
+    if required_cmd_args:
+        emit_info("\n  ⚙️ Configuration:")
+        for arg_config in required_cmd_args:
+            name = arg_config.get("name", "")
+            prompt_text = arg_config.get("prompt", name)
+            default = arg_config.get("default", "")
+            required = arg_config.get("required", True)
+
+            prompt_str = f"     {prompt_text}"
+            if default:
+                prompt_str += f" [{default}]"
+            if not required:
+                prompt_str += " (optional)"
+
+            try:
+                value = safe_input(f"{prompt_str}: ")
+                if value:
+                    cmd_args[name] = value
+                elif default:
+                    cmd_args[name] = default
+                elif required:
+                    emit_warning(f"Required value '{name}' not provided")
+                    return None
+            except (KeyboardInterrupt, EOFError):
+                emit_info("")
+                emit_warning("Installation cancelled")
+                return None
+
+    return {
+        "name": server_name,
+        "env_vars": env_vars,
+        "cmd_args": cmd_args,
+    }
+
+
+def install_catalog_server(manager, server, config: Dict) -> bool:
+    """Install a server from the catalog with the given configuration.
+
+    Args:
+        manager: MCP manager instance
+        server: Server template from catalog
+        config: Configuration dict with 'name', 'env_vars', 'cmd_args'
+
+    Returns:
+        True if successful, False otherwise
+    """
+    import uuid
+
+    from .wizard_utils import install_server_from_catalog
+
+    server_name = config["name"]
+    env_vars = config["env_vars"]
+    cmd_args = config["cmd_args"]
+
+    # Generate a group ID for messages
+    group_id = f"mcp-install-{uuid.uuid4().hex[:8]}"
+
+    emit_info(f"\n  📦 Installing {server.display_name} as '{server_name}'...")
+
+    success = install_server_from_catalog(
+        manager, server, server_name, env_vars, cmd_args, group_id
+    )
+
+    if success:
+        emit_success(f"\n  ✅ Successfully installed '{server_name}'!")
+        emit_info(f"  Use '/mcp start {server_name}' to start the server.\n")
+    else:
+        emit_warning("\n  ❌ Installation failed.\n")
+
+    return success