claude-mpm 4.16.0__py3-none-any.whl → 4.25.10__py3-none-any.whl

claude_mpm/services/mcp_config_manager.py

@@ -1130,139 +1130,15 @@ class MCPConfigManager:
         """
         Detect and fix corrupted MCP service installations.
 
-        This method:
-        1. Tests each MCP service for import/execution errors
-        2. Automatically reinstalls corrupted services
-        3. Fixes missing dependencies (like mcp-ticketer's gql)
-        4. Validates fixes worked
+        NOTE: Proactive health checking has been disabled.
+        Each MCP service should stand on its own and handle its own issues.
+        This function now only returns success without checking services.
 
         Returns:
             Tuple of (success, message)
         """
-        services_to_fix = []
-        fixed_services = []
-        failed_services = []
-
-        # Check each service for issues
-        for service_name in self.PIPX_SERVICES:
-            # Check if service is enabled in config
-            if not self.should_enable_service(service_name):
-                self.logger.debug(f"Skipping {service_name} (disabled in config)")
-                continue
-
-            self.logger.debug(f"🔍 Checking {service_name} for issues...")
-            issue_type = self._detect_service_issue(service_name)
-            if issue_type:
-                services_to_fix.append((service_name, issue_type))
-                self.logger.debug(f"  ⚠️  Found issue with {service_name}: {issue_type}")
-            else:
-                self.logger.debug(f"  ✅ {service_name} is functioning correctly")
-
-        if not services_to_fix:
-            return True, "All MCP services are functioning correctly"
-
-        # Fix each problematic service
-        for service_name, issue_type in services_to_fix:
-            self.logger.info(f"🔧 Fixing {service_name}: {issue_type}")
-
-            if issue_type == "not_installed":
-                # Install the service
-                success, method = self._install_service_with_fallback(service_name)
-                if success:
-                    fixed_services.append(f"{service_name} (installed via {method})")
-                else:
-                    failed_services.append(f"{service_name} (installation failed)")
-
-            elif issue_type == "import_error":
-                # Reinstall to fix corrupted installation
-                self.logger.info(
-                    f"  Reinstalling {service_name} to fix import errors..."
-                )
-                success = self._reinstall_service(service_name)
-                if success:
-                    # NOTE: Removed automatic dependency injection workaround
-                    # Package maintainers should fix dependency declarations
-                    fixed_services.append(f"{service_name} (reinstalled)")
-                else:
-                    failed_services.append(f"{service_name} (reinstall failed)")
-
-            elif issue_type == "missing_dependency":
-                # Fix missing dependencies - try injection first, then reinstall if needed
-                self.logger.info(
-                    f"  {service_name} has missing dependencies - attempting fix..."
-                )
-
-                # First try to inject dependencies without reinstalling
-                injection_success = self._inject_missing_dependencies(service_name)
-
-                if injection_success:
-                    # Verify the fix worked
-                    issue_after_injection = self._detect_service_issue(service_name)
-                    if issue_after_injection is None:
-                        fixed_services.append(f"{service_name} (dependencies injected)")
-                        self.logger.info(
-                            f"  ✅ Fixed {service_name} with dependency injection"
-                        )
-                        continue  # Move to next service
-
-                # If injection alone didn't work, try full reinstall
-                self.logger.info(
-                    "  Dependency injection insufficient, trying full reinstall..."
-                )
-                success = self._auto_reinstall_mcp_service(service_name)
-                if success:
-                    fixed_services.append(
-                        f"{service_name} (auto-reinstalled with dependencies)"
-                    )
-                else:
-                    # Provide specific manual fix for known services
-                    if service_name == "mcp-ticketer":
-                        self.logger.warning(
-                            f"  Auto-fix failed for {service_name}. Manual fix: "
-                            f"pipx uninstall {service_name} && pipx install {service_name} && pipx inject {service_name} gql"
-                        )
-                    else:
-                        self.logger.warning(
-                            f"  Auto-reinstall failed for {service_name}. Manual fix: "
-                            f"pipx uninstall {service_name} && pipx install {service_name}"
-                        )
-                    failed_services.append(f"{service_name} (auto-reinstall failed)")
-
-            elif issue_type == "path_issue":
-                # Path issues are handled by config updates
-                self.logger.info(
-                    f"  Path issue for {service_name} will be fixed by config update"
-                )
-                fixed_services.append(f"{service_name} (config updated)")
-
-        # Build result message
-        messages = []
-        if fixed_services:
-            messages.append(f"✅ Fixed: {', '.join(fixed_services)}")
-        if failed_services:
-            messages.append(f"❌ Failed: {', '.join(failed_services)}")
-
-        # Return success if at least some services were fixed
-        success = len(fixed_services) > 0 or len(failed_services) == 0
-        message = " | ".join(messages) if messages else "No services needed fixing"
-
-        # Provide manual fix instructions if auto-fix failed
-        if failed_services:
-            message += "\n\n💡 Manual fix instructions:"
-            for failed in failed_services:
-                service = failed.split(" ")[0]
-                if service in self.SERVICE_MISSING_DEPENDENCIES:
-                    deps = " ".join(
-                        [
-                            f"&& pipx inject {service} {dep}"
-                            for dep in self.SERVICE_MISSING_DEPENDENCIES[service]
-                        ]
-                    )
-                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service} {deps}"
-                else:
-                    message += f"\n  • {service}: pipx uninstall {service} && pipx install {service}"
-
-        return success, message
+        # Services should stand on their own - no proactive health checking
+        return True, "MCP services managing their own health"
 
     def _detect_service_issue(self, service_name: str) -> Optional[str]:
         """
@@ -1497,7 +1373,7 @@ class MCPConfigManager:
                 )
 
                 if result.returncode == 0:
-                    self.logger.info(f"    ✅ Successfully injected {dep}")
+                    self.logger.debug(f"    ✅ Successfully injected {dep}")
                 # Check if already injected (pipx will complain if package already exists)
                 elif (
                     "already satisfied" in result.stderr.lower()
@@ -1582,7 +1458,7 @@ class MCPConfigManager:
                     )
 
             # Verify the reinstall worked
-            self.logger.info(f"  → Verifying {service_name} installation...")
+            self.logger.debug(f"  → Verifying {service_name} installation...")
             issue = self._detect_service_issue(service_name)
 
             if issue is None:

claude_mpm/services/mcp_gateway/README.md

@@ -0,0 +1,185 @@
+# MCP Gateway Service
+
+## Overview
+
+The MCP Gateway is a standards-compliant implementation of the Model Context Protocol (MCP) for Claude MPM. It provides a simple, stdio-based server that enables seamless integration with Claude Code.
+
+**NOTE: MCP is ONLY for Claude Code - NOT for Claude Code.**
+Claude Code uses a different system for agent deployment via the `.claude/agents/` directory.
+
+## Architecture
+
+The MCP Gateway uses the official Anthropic MCP Python SDK with:
+
+- **Standards compliance** with the official MCP specification
+- **Stdio-based communication** for Claude Code integration
+- **Simple JSON-RPC protocol** over stdin/stdout
+- **Tool registry system** for extensible functionality
+- **Comprehensive error handling** and logging
+
+## Structure
+
+```
+mcp_gateway/
+├── core/           # Core interfaces and base classes
+│   ├── interfaces.py    # MCP service interfaces
+│   ├── base.py         # Base MCP service class
+│   └── exceptions.py   # MCP-specific exceptions
+├── config/         # Configuration management
+│   ├── configuration.py    # Main configuration service
+│   ├── config_loader.py   # Configuration discovery and loading
+│   └── config_schema.py   # Configuration validation
+├── server/         # MCP server implementation (ISS-0035)
+├── tools/          # Tool registry and adapters (ISS-0036)
+└── registry/       # Service discovery and registration
+```
+
+## Features
+
+### Implemented
+- ✅ **Official MCP Server** - Standards-compliant implementation using Anthropic's MCP SDK
+- ✅ **Tool Registry System** - Extensible tool management and discovery
+- ✅ **Stdio Communication** - Standard MCP protocol over stdin/stdout
+- ✅ **Configuration Management** - YAML-based configuration with validation
+- ✅ **Built-in Tools** - Echo, calculator, and system info tools
+- ✅ **CLI Integration** - Complete command-line interface for management
+- ✅ **Error Handling** - Comprehensive error handling and logging
+
+### Key Features
+- **Protocol Handler** - Stdio-based MCP protocol handler, not a background service
+- **Claude Code Ready** - Direct integration with Claude Code MCP client
+- **Extensible** - Easy to add new tools and capabilities
+- **Standards Compliant** - Follows official MCP specification exactly
+
+## Quick Start
+
+### 1. Check Status
+```bash
+claude-mpm mcp status
+```
+
+### 2. Test Tools
+```bash
+# Test echo tool
+claude-mpm mcp test echo --args '{"message": "Hello MCP!"}'
+
+# Test calculator
+claude-mpm mcp test calculator --args '{"operation": "add", "a": 5, "b": 3}'
+
+# Test system info
+claude-mpm mcp test system_info
+```
+
+### 3. Start MCP Gateway Handler
+```bash
+# Start gateway handler for Claude Code integration
+claude-mpm mcp start
+```
+
+The gateway handler will listen for MCP protocol messages via stdin/stdout. This is typically invoked by Claude Code, not run directly by users.
+
+### 4. Claude Code Integration
+Add to your Claude Code configuration (~/.claude.json):
+```json
+{
+  "mcpServers": {
+    "claude-mpm": {
+      "command": "python",
+      "args": ["-m", "claude_mpm.cli", "mcp", "start"],
+      "cwd": "/path/to/claude-mpm"
+    }
+  }
+}
+```
+
+## Configuration
+
+The MCP Gateway uses a hierarchical configuration system with the following priority:
+
+1. Default configuration (built-in)
+2. Configuration file (YAML)
+3. Environment variables (highest priority)
+
+### Configuration File Locations
+
+The system searches for configuration in these locations (in order):
+- `~/.claude/mcp/config.yaml` (user-specific)
+- `~/.claude/mcp_gateway.yaml`
+- `~/.config/claude-mpm/mcp_gateway.yaml`
+- `./mcp_gateway.yaml` (project-specific)
+- `./config/mcp_gateway.yaml`
+- `./.claude/mcp_gateway.yaml`
+- `/etc/claude-mpm/mcp_gateway.yaml` (system-wide)
+
+### Environment Variables
+
+Override configuration using environment variables:
+```bash
+export MCP_GATEWAY_SERVER_NAME=my-gateway
+export MCP_GATEWAY_TOOLS_TIMEOUT_DEFAULT=60
+export MCP_GATEWAY_LOGGING_LEVEL=DEBUG
+```
+
+## Usage
+
+### Basic Setup
+
+```python
+from claude_mpm.services.mcp_gateway import MCPConfiguration, MCPConfigLoader
+
+# Load configuration
+config_loader = MCPConfigLoader()
+config = MCPConfiguration()
+await config.initialize()
+
+# Access configuration
+server_name = config.get("mcp.server.name")
+tools_enabled = config.get("mcp.tools.enabled")
+```
+
+### Service Registration
+
+The MCP Gateway services are automatically registered with the claude-mpm service container:
+
+```python
+from claude_mpm.services import MCPConfiguration, BaseMCPService
+
+# Services are available through lazy loading
+config = MCPConfiguration()
+```
+
+## Development
+
+### Adding New MCP Services
+
+1. Define the interface in `core/interfaces.py`
+2. Create base implementation in appropriate module
+3. Register in service container if needed
+4. Add lazy import to `__init__.py`
+5. Update documentation
+
+### Testing
+
+Run tests with:
+```bash
+pytest tests/services/mcp_gateway/
+```
+
+## Dependencies
+
+- Python 3.8+
+- mcp>=0.1.0 (Anthropic's MCP package)
+- PyYAML for configuration
+- asyncio for async operations
+
+## Related Issues
+
+- ISS-0034: Infrastructure Setup (this implementation)
+- ISS-0035: MCP Server Core Implementation
+- ISS-0036: Tool Registry & Discovery System
+- ISS-0037: stdio Communication Handler
+- ISS-0038: Tool Adapter Framework
+
+## Notes
+
+This is the foundation implementation for the MCP Gateway. The actual server functionality, tool registry, and communication handlers will be implemented in subsequent tickets as part of the EP-0007 epic.

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -163,17 +163,21 @@ class MCPAutoConfigurator:
         Returns:
             True if user agrees, False if declines, None if timeout
         """
-        print("\n" + "=" * 60)
-        print("🔧 MCP Gateway Configuration")
-        print("=" * 60)
-        print("\nClaude MPM can automatically configure MCP Gateway for")
-        print("Claude Code integration. This enables advanced features:")
-        print("  • File analysis and summarization")
-        print("  • System diagnostics")
-        print("  • Ticket management")
-        print("  • And more...")
-        print("\nWould you like to configure it now? (y/n)")
-        print(f"(Auto-declining in {timeout} seconds)")
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("🔧 MCP Gateway Configuration", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+        print(
+            "\nClaude MPM can automatically configure MCP Gateway for", file=sys.stderr
+        )
+        print(
+            "Claude Code integration. This enables advanced features:", file=sys.stderr
+        )
+        print("  • File analysis and summarization", file=sys.stderr)
+        print("  • System diagnostics", file=sys.stderr)
+        print("  • Ticket management", file=sys.stderr)
+        print("  • And more...", file=sys.stderr)
+        print("\nWould you like to configure it now? (y/n)", file=sys.stderr)
+        print(f"(Auto-declining in {timeout} seconds)", file=sys.stderr)
 
         # Use threading for cross-platform timeout support
         # Python 3.7+ has queue built-in - no need to check, we require 3.10+
@@ -203,7 +207,7 @@ class MCPAutoConfigurator:
 
         if input_thread.is_alive():
             # Timed out
-            print("\n(Timed out - declining)")
+            print("\n(Timed out - declining)", file=sys.stderr)
             return None
         # Got input
         return user_input in ["y", "yes"]
@@ -220,7 +224,7 @@ class MCPAutoConfigurator:
             if self.claude_config_path.exists():
                 backup_path = self._create_backup()
                 if backup_path:
-                    print(f"✅ Backup created: {backup_path}")
+                    print(f"✅ Backup created: {backup_path}", file=sys.stderr)
 
             # Load or create configuration
             config = self._load_or_create_config()
@@ -232,7 +236,7 @@ class MCPAutoConfigurator:
             # Find claude-mpm executable
             executable = self._find_claude_mpm_executable()
             if not executable:
-                print("❌ Could not find claude-mpm executable")
+                print("❌ Could not find claude-mpm executable", file=sys.stderr)
                 return False
 
             # Configure MCP server
@@ -246,20 +250,22 @@ class MCPAutoConfigurator:
             with self.claude_config_path.open("w") as f:
                 json.dump(config, f, indent=2)
 
-            print(f"✅ Configuration saved to: {self.claude_config_path}")
-            print("\n🎉 MCP Gateway configured successfully!")
-            print("\nNext steps:")
-            print("1. Restart Claude Code (if running)")
-            print("2. Look for the MCP icon in the interface")
-            print("3. Try @claude-mpm-gateway in a conversation")
+            print(
+                f"✅ Configuration saved to: {self.claude_config_path}", file=sys.stderr
+            )
+            print("\n🎉 MCP Gateway configured successfully!", file=sys.stderr)
+            print("\nNext steps:", file=sys.stderr)
+            print("1. Restart Claude Code (if running)", file=sys.stderr)
+            print("2. Look for the MCP icon in the interface", file=sys.stderr)
+            print("3. Try @claude-mpm-gateway in a conversation", file=sys.stderr)
 
             return True
 
         except Exception as e:
             self.logger.error(f"Auto-configuration failed: {e}")
-            print(f"❌ Configuration failed: {e}")
-            print("\nYou can configure manually with:")
-            print("  claude-mpm mcp install")
+            print(f"❌ Configuration failed: {e}", file=sys.stderr)
+            print("\nYou can configure manually with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
             return False
 
     def _create_backup(self) -> Optional[Path]:
@@ -344,8 +350,8 @@ class MCPAutoConfigurator:
         if user_choice:
             return self.auto_configure()
         if user_choice is False:  # User explicitly said no
-            print("\n📝 You can configure MCP later with:")
-            print("  claude-mpm mcp install")
+            print("\n📝 You can configure MCP later with:", file=sys.stderr)
+            print("  claude-mpm mcp install", file=sys.stderr)
         # If timeout (None), don't show additional message
         return False
 

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -215,7 +215,7 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                     current[part] = {}
                 elif not isinstance(current[part], dict):
                     self.log_warning(
-                        f"Cannot override non-dict config at {'.'.join(config_path[:i+1])}"
+                        f"Cannot override non-dict config at {'.'.join(config_path[: i + 1])}"
                     )
                     break
                 current = current[part]

claude_mpm/services/mcp_gateway/core/process_pool.py

@@ -864,7 +864,7 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
     # Check if running in a non-interactive context
     try:
         if confirm_operation(message):
-            print("🚀 Updating kuzu-memory...")
+            print("🚀 Updating kuzu-memory...", file=sys.stderr)
             try:
                 result = subprocess.run(
                     ["pipx", "upgrade", "kuzu-memory"],
@@ -874,28 +874,37 @@ def _prompt_kuzu_update(current: str, latest: str) -> None:
                     check=False,
                 )
                 if result.returncode == 0:
-                    print("✅ Successfully updated kuzu-memory!")
+                    print("✅ Successfully updated kuzu-memory!", file=sys.stderr)
                     logger.info(f"Updated kuzu-memory from {current} to {latest}")
                 else:
-                    print(f"⚠️ Update failed: {result.stderr}")
+                    print(f"⚠️ Update failed: {result.stderr}", file=sys.stderr)
                     logger.warning(f"kuzu-memory update failed: {result.stderr}")
             except subprocess.TimeoutExpired:
-                print("⚠️ Update timed out. Please try again later.")
+                print("⚠️ Update timed out. Please try again later.", file=sys.stderr)
                 logger.warning("kuzu-memory update timed out")
             except Exception as e:
-                print(f"⚠️ Update failed: {e}")
+                print(f"⚠️ Update failed: {e}", file=sys.stderr)
                 logger.warning(f"kuzu-memory update error: {e}")
         else:
             # User declined update
-            print("\n  To skip this version permanently, run:")
-            print(f"    claude-mpm config set-skip-version kuzu-memory {latest}")
-            print("  To disable update checks for kuzu-memory:")
-            print("    claude-mpm config disable-update-checks kuzu-memory")
+            print("\n  To skip this version permanently, run:", file=sys.stderr)
+            print(
+                f"    claude-mpm config set-skip-version kuzu-memory {latest}",
+                file=sys.stderr,
+            )
+            print("  To disable update checks for kuzu-memory:", file=sys.stderr)
+            print(
+                "    claude-mpm config disable-update-checks kuzu-memory",
+                file=sys.stderr,
+            )
 
             # Ask if user wants to skip this version
             if confirm_operation("\n  Skip this version in future checks?"):
                 UpdatePreferences.set_skip_version("kuzu-memory", latest)
-                print(f"  Version {latest} will be skipped in future checks.")
+                print(
+                    f"  Version {latest} will be skipped in future checks.",
+                    file=sys.stderr,
+                )
     except (KeyboardInterrupt, EOFError):
         # User interrupted or input not available
         pass

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -65,7 +65,6 @@ def apply_backward_compatibility_patches():
                         and hasattr(request, "params")
                         and request.params is not None
                     ):
-
                         # Convert params to dict to check for clientInfo
                         params_dict = request.params
                         if hasattr(params_dict, "model_dump"):
@@ -542,7 +541,6 @@ class SimpleMCPServer:
 
                         result = f"Python: {sys.version}"
                     elif info_type == "cwd":
-
                         result = f"Working Directory: {Path.cwd()}"
                     elif info_type == "all":
                         import datetime

claude_mpm/services/mcp_gateway/tools/document_summarizer.py

@@ -73,7 +73,7 @@ class LRUCache:
             if not self.cache:
                 break
             # Remove least recently used item
-            removed_key, removed_value = self.cache.popitem(last=False)
+            _removed_key, removed_value = self.cache.popitem(last=False)
             self.current_memory -= removed_value.get("size_bytes", 0)
 
         # Add new item

claude_mpm/services/mcp_gateway/tools/external_mcp_services.py

@@ -161,12 +161,17 @@ class ExternalMCPService(BaseToolAdapter):
 
             if interactive:
                 # Show user-friendly installation prompt
-                print(f"\n⚠️  {self.package_name} not found")
-                print("This package enables enhanced functionality (optional).")
-                print("\nInstallation options:")
-                print("1. Install via pip (recommended for this project)")
-                print("2. Install via pipx (isolated, system-wide)")
-                print("3. Skip (continue without this package)")
+                print(f"\n⚠️  {self.package_name} not found", file=sys.stderr)
+                print(
+                    "This package enables enhanced functionality (optional).",
+                    file=sys.stderr,
+                )
+                print("\nInstallation options:", file=sys.stderr)
+                print(
+                    "1. Install via pip (recommended for this project)", file=sys.stderr
+                )
+                print("2. Install via pipx (isolated, system-wide)", file=sys.stderr)
+                print("3. Skip (continue without this package)", file=sys.stderr)
 
                 try:
                     choice = input("\nChoose option (1/2/3) [1]: ").strip() or "1"
@@ -180,7 +185,7 @@ class ExternalMCPService(BaseToolAdapter):
                         )
                         return False
                 except (EOFError, KeyboardInterrupt):
-                    print("\nInstallation cancelled")
+                    print("\nInstallation cancelled", file=sys.stderr)
                     return False
             else:
                 # Non-interactive: default to pip
@@ -201,7 +206,7 @@ class ExternalMCPService(BaseToolAdapter):
     async def _install_via_pip(self) -> bool:
         """Install package via pip."""
         try:
-            print(f"\n📦 Installing {self.package_name} via pip...")
+            print(f"\n📦 Installing {self.package_name} via pip...", file=sys.stderr)
             result = subprocess.run(
                 [sys.executable, "-m", "pip", "install", self.package_name],
                 capture_output=True,
@@ -211,21 +216,21 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if result.returncode == 0:
-                print(f"✓ Successfully installed {self.package_name}")
+                print(f"✓ Successfully installed {self.package_name}", file=sys.stderr)
                 self.logger.info(f"Successfully installed {self.package_name} via pip")
                 return True
 
             error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-            print(f"✗ Installation failed: {error_msg}")
+            print(f"✗ Installation failed: {error_msg}", file=sys.stderr)
             self.logger.error(f"Failed to install {self.package_name}: {error_msg}")
             return False
 
         except subprocess.TimeoutExpired:
-            print("✗ Installation timed out")
+            print("✗ Installation timed out", file=sys.stderr)
             self.logger.error(f"Installation of {self.package_name} timed out")
             return False
         except Exception as e:
-            print(f"✗ Installation error: {e}")
+            print(f"✗ Installation error: {e}", file=sys.stderr)
             self.logger.error(f"Error installing {self.package_name}: {e}")
             return False
 
@@ -242,12 +247,12 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if pipx_check.returncode != 0:
-                print("✗ pipx is not installed")
-                print("Install pipx first: python -m pip install pipx")
+                print("✗ pipx is not installed", file=sys.stderr)
+                print("Install pipx first: python -m pip install pipx", file=sys.stderr)
                 self.logger.error("pipx not available for installation")
                 return False
 
-            print(f"\n📦 Installing {self.package_name} via pipx...")
+            print(f"\n📦 Installing {self.package_name} via pipx...", file=sys.stderr)
             result = subprocess.run(
                 ["pipx", "install", self.package_name],
                 capture_output=True,
@@ -257,26 +262,26 @@ class ExternalMCPService(BaseToolAdapter):
             )
 
             if result.returncode == 0:
-                print(f"✓ Successfully installed {self.package_name}")
+                print(f"✓ Successfully installed {self.package_name}", file=sys.stderr)
                 self.logger.info(f"Successfully installed {self.package_name} via pipx")
                 return True
 
             error_msg = result.stderr.strip() if result.stderr else "Unknown error"
-            print(f"✗ Installation failed: {error_msg}")
+            print(f"✗ Installation failed: {error_msg}", file=sys.stderr)
             self.logger.error(f"Failed to install {self.package_name}: {error_msg}")
             return False
 
         except FileNotFoundError:
-            print("✗ pipx command not found")
-            print("Install pipx first: python -m pip install pipx")
+            print("✗ pipx command not found", file=sys.stderr)
+            print("Install pipx first: python -m pip install pipx", file=sys.stderr)
             self.logger.error("pipx command not found")
             return False
         except subprocess.TimeoutExpired:
-            print("✗ Installation timed out")
+            print("✗ Installation timed out", file=sys.stderr)
             self.logger.error(f"Installation of {self.package_name} timed out")
             return False
         except Exception as e:
-            print(f"✗ Installation error: {e}")
+            print(f"✗ Installation error: {e}", file=sys.stderr)
             self.logger.error(f"Error installing {self.package_name}: {e}")
             return False