claude-mpm 4.0.23__py3-none-any.whl → 4.0.25__py3-none-any.whl

claude_mpm/cli/commands/info.py

@@ -1,90 +1,199 @@
-from pathlib import Path
-
 """
 Info command implementation for claude-mpm.
 
 WHY: This module provides system information and configuration details to help
 users understand their claude-mpm setup and troubleshoot issues.
+
+DESIGN DECISIONS:
+- Use BaseCommand for consistent CLI patterns
+- Leverage shared utilities for argument parsing and output formatting
+- Support multiple output formats (json, yaml, table, text)
+- Provide comprehensive system information for troubleshooting
 """
 
 import shutil
-
-from ...core.logger import get_logger
+from pathlib import Path
+from typing import Dict, Any, List
+
+from ..shared import BaseCommand, CommandResult
+
+
+class InfoCommand(BaseCommand):
+    """Information display command using shared utilities."""
+
+    def __init__(self):
+        super().__init__("info")
+
+    def validate_args(self, args) -> str:
+        """Validate command arguments."""
+        # Info command doesn't require specific validation
+        return None
+
+    def run(self, args) -> CommandResult:
+        """Execute the info command."""
+        try:
+            # Gather system information
+            info_data = self._gather_system_info(args)
+
+            output_format = getattr(args, 'format', 'text')
+
+            if output_format in ['json', 'yaml']:
+                # Structured output
+                return CommandResult.success_result("System information retrieved", data=info_data)
+            else:
+                # Text output
+                self._display_text_info(info_data)
+                return CommandResult.success_result("System information displayed")
+
+        except Exception as e:
+            self.logger.error(f"Error gathering system info: {e}", exc_info=True)
+            return CommandResult.error_result(f"Error gathering system info: {e}")
+
+    def _gather_system_info(self, args) -> Dict[str, Any]:
+        """Gather comprehensive system information."""
+        try:
+            from ...core.framework_loader import FrameworkLoader
+        except ImportError:
+            from claude_mpm.core.framework_loader import FrameworkLoader
+
+        # Framework information
+        framework_path = getattr(args, 'framework_path', None)
+        loader = FrameworkLoader(framework_path)
+
+        framework_info = {
+            "loaded": loader.framework_content["loaded"],
+            "name": "claude-multiagent-pm" if loader.framework_content["loaded"] else "Not found",
+            "version": loader.framework_content.get('version', 'unknown'),
+            "path": str(loader.framework_path) if loader.framework_path else None,
+            "agents": loader.get_agent_list() if loader.framework_content["loaded"] else []
+        }
+
+        # Configuration information
+        config_info = {
+            "log_directory": getattr(args, 'log_dir', None) or '~/.claude-mpm/logs'
+        }
+
+        # Agent hierarchy
+        agent_hierarchy = {}
+        core_agents = []
+        if loader.agent_registry:
+            hierarchy = loader.agent_registry.get_agent_hierarchy()
+            agent_hierarchy = {
+                "project_agents": len(hierarchy['project']),
+                "user_agents": len(hierarchy['user']),
+                "system_agents": len(hierarchy['system']),
+                "project_agent_list": hierarchy['project'],
+                "user_agent_list": hierarchy['user'],
+                "system_agent_list": hierarchy['system']
+            }
+            core_agents = loader.agent_registry.get_core_agents()
+
+        # Dependencies check
+        dependencies = self._check_dependencies()
+
+        return {
+            "framework": framework_info,
+            "configuration": config_info,
+            "agent_hierarchy": agent_hierarchy,
+            "core_agents": core_agents,
+            "dependencies": dependencies
+        }
+
+    def _check_dependencies(self) -> Dict[str, Any]:
+        """Check system dependencies."""
+        dependencies = {}
+
+        # Check Claude CLI
+        claude_path = shutil.which("claude")
+        dependencies["claude_cli"] = {
+            "installed": bool(claude_path),
+            "path": claude_path,
+            "status": "✓ Installed" if claude_path else "✗ Not found in PATH"
+        }
+
+        # Check ai-trackdown-pytools
+        try:
+            import ai_trackdown_pytools
+            dependencies["ai_trackdown_pytools"] = {
+                "installed": True,
+                "status": "✓ Installed"
+            }
+        except ImportError:
+            dependencies["ai_trackdown_pytools"] = {
+                "installed": False,
+                "status": "✗ Not installed"
+            }
+
+        # Check Claude Code hooks
+        claude_settings = Path.home() / ".claude" / "settings.json"
+        dependencies["claude_code_hooks"] = {
+            "installed": claude_settings.exists(),
+            "settings_path": str(claude_settings),
+            "status": "✓ Installed" if claude_settings.exists() else "✗ Not installed",
+            "install_command": "python scripts/install_hooks.py" if not claude_settings.exists() else None
+        }
+
+        return dependencies
+
+    def _display_text_info(self, info_data: Dict[str, Any]) -> None:
+        """Display information in text format."""
+        print("Claude MPM - Multi-Agent Project Manager")
+        print("=" * 50)
+
+        # Framework info
+        framework = info_data["framework"]
+        print(f"Framework: {framework['name']}")
+        if framework["loaded"]:
+            print(f"Version: {framework['version']}")
+            print(f"Path: {framework['path']}")
+            print(f"Agents: {', '.join(framework['agents'])}")
+
+        print()
+
+        # Configuration
+        config = info_data["configuration"]
+        print("Configuration:")
+        print(f"  Log directory: {config['log_directory']}")
+
+        # Agent hierarchy
+        hierarchy = info_data["agent_hierarchy"]
+        if hierarchy:
+            print("\nAgent Hierarchy:")
+            print(f"  Project agents: {hierarchy['project_agents']}")
+            print(f"  User agents: {hierarchy['user_agents']}")
+            print(f"  System agents: {hierarchy['system_agents']}")
+
+        # Core agents
+        core_agents = info_data["core_agents"]
+        if core_agents:
+            print(f"\nCore Agents: {', '.join(core_agents)}")
+
+        # Dependencies
+        print("\nDependencies:")
+        deps = info_data["dependencies"]
+
+        for dep_name, dep_info in deps.items():
+            print(f"  {dep_info['status']}")
+            if dep_name == "claude_cli" and dep_info["path"]:
+                print(f"    Path: {dep_info['path']}")
+            elif dep_name == "claude_code_hooks":
+                if dep_info["installed"]:
+                    print("     Use /mpm commands in Claude Code")
+                else:
+                    print(f"     Run: {dep_info['install_command']}")
 
 
 def show_info(args):
     """
-    Show framework and configuration information.
+    Main entry point for info command.
 
-    WHY: Users need to verify their installation, check dependencies, and understand
-    what agents are available. This command provides a comprehensive overview of
-    the claude-mpm environment.
+    This function maintains backward compatibility while using the new BaseCommand pattern.
+    """
+    command = InfoCommand()
+    result = command.execute(args)
 
-    DESIGN DECISION: We check for all major components and dependencies, showing
-    both what's working (✓) and what's missing (✗) to help with troubleshooting.
+    # Print result if structured output format is requested
+    if hasattr(args, 'format') and args.format in ['json', 'yaml']:
+        command.print_result(result, args)
 
-    Args:
-        args: Parsed command line arguments
-    """
-    try:
-        from ...core.framework_loader import FrameworkLoader
-    except ImportError:
-        from claude_mpm.core.framework_loader import FrameworkLoader
-
-    print("Claude MPM - Multi-Agent Project Manager")
-    print("=" * 50)
-
-    # Framework info
-    loader = FrameworkLoader(args.framework_path)
-    if loader.framework_content["loaded"]:
-        print(f"Framework: claude-multiagent-pm")
-        print(f"Version: {loader.framework_content['version']}")
-        print(f"Path: {loader.framework_path}")
-        print(f"Agents: {', '.join(loader.get_agent_list())}")
-    else:
-        print("Framework: Not found (using minimal instructions)")
-
-    print()
-
-    # Configuration
-    print("Configuration:")
-    print(f"  Log directory: {args.log_dir or '~/.claude-mpm/logs'}")
-
-    # Show agent hierarchy
-    if loader.agent_registry:
-        hierarchy = loader.agent_registry.get_agent_hierarchy()
-        print("\nAgent Hierarchy:")
-        print(f"  Project agents: {len(hierarchy['project'])}")
-        print(f"  User agents: {len(hierarchy['user'])}")
-        print(f"  System agents: {len(hierarchy['system'])}")
-
-        # Show core agents
-        core_agents = loader.agent_registry.get_core_agents()
-        print(f"\nCore Agents: {', '.join(core_agents)}")
-
-    # Check dependencies
-    print("\nDependencies:")
-
-    # Check Claude CLI
-    claude_path = shutil.which("claude")
-    if claude_path:
-        print(f"  ✓ Claude CLI: {claude_path}")
-    else:
-        print("  ✗ Claude CLI: Not found in PATH")
-
-    # Check ai-trackdown-pytools
-    try:
-        import ai_trackdown_pytools
-
-        print("  ✓ ai-trackdown-pytools: Installed")
-    except ImportError:
-        print("  ✗ ai-trackdown-pytools: Not installed")
-
-    # Check Claude Code hooks
-    claude_settings = Path.home() / ".claude" / "settings.json"
-    if claude_settings.exists():
-        print("  ✓ Claude Code Hooks: Installed")
-        print("     Use /mpm commands in Claude Code")
-    else:
-        print("  ✗ Claude Code Hooks: Not installed")
-        print("     Run: python scripts/install_hooks.py")
+    return result.exit_code

claude_mpm/cli/commands/mcp_command_router.py

@@ -122,82 +122,11 @@ class MCPCommandRouter:
 
     def _run_server(self, args) -> int:
         """Run server command handler - direct server execution."""
-        try:
-            self.logger.info("Starting MCP server directly via CLI command")
-
-            # Import the server components
-            from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
-
-            # Create server instance
-            server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
-
-            if args.test:
-                self.logger.info("Running in test mode")
-                print("🧪 Starting MCP server in test mode...", file=sys.stderr)
-                print("   This will run the server with stdio communication.", file=sys.stderr)
-                print("   Press Ctrl+C to stop.\n", file=sys.stderr)
-
-            # Run the server, handling event loop properly
-            try:
-                # Check if there's already an event loop running
-                loop = asyncio.get_running_loop()
-                # If we get here, there's already a loop running
-                # We need to run in a subprocess to avoid conflicts
-                import subprocess
-                import json
-
-                # Create a simple script to run the server
-                script_content = f'''
-import asyncio
-import sys
-import os
-sys.path.insert(0, "{os.path.join(os.path.dirname(__file__), '..', '..', '..')}")
-
-async def main():
-    from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
-    server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
-    await server.run()
-
-if __name__ == "__main__":
-    asyncio.run(main())
-'''
-
-                # Write the script to a temporary file
-                import tempfile
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
-                    f.write(script_content)
-                    temp_script = f.name
-
-                try:
-                    # Run the server in a subprocess
-                    result = subprocess.run([sys.executable, temp_script])
-                    return result.returncode
-                finally:
-                    # Clean up the temporary file
-                    os.unlink(temp_script)
-
-            except RuntimeError:
-                # No event loop running, we can use asyncio.run
-                async def run_async():
-                    await server.run()
-
-                asyncio.run(run_async())
-            return 0
-
-        except ImportError as e:
-            self.logger.error(f"Failed to import MCP server: {e}")
-            print(f"❌ Error: Could not import MCP server components: {e}", file=sys.stderr)
-            print("\nMake sure the MCP package is installed:", file=sys.stderr)
-            print("  pip install mcp", file=sys.stderr)
-            return 1
-        except KeyboardInterrupt:
-            self.logger.info("MCP server interrupted")
-            print("\n🛑 MCP server stopped", file=sys.stderr)
-            return 0
-        except Exception as e:
-            self.logger.error(f"Server error: {e}")
-            print(f"❌ Error running server: {e}", file=sys.stderr)
-            return 1
+        # Simply delegate to the async start_server method using asyncio.run
+        from .mcp_server_commands import MCPServerCommands
+        
+        handler = MCPServerCommands(self.logger)
+        return asyncio.run(handler.start_server(args))
 
     def _show_help(self):
         """Show available MCP commands."""

claude_mpm/cli/commands/mcp_install_commands.py

@@ -20,7 +20,7 @@ class MCPInstallCommands:
         """Install and configure MCP gateway.
 
         WHY: This command installs the MCP package dependencies and configures
-        Claude Desktop to use the MCP gateway server directly via the CLI command.
+        Claude Code to use the MCP gateway server directly via the CLI command.
 
         DESIGN DECISION: We handle both package installation and configuration
         in one command for user convenience, using the new direct CLI approach.
@@ -44,15 +44,15 @@ class MCPInstallCommands:
                 print("\nPlease install manually with: pip install mcp")
                 return 1
 
-        # Step 2: Configure Claude Desktop with the new CLI command
-        print("\n2️⃣  Configuring Claude Desktop...")
+        # Step 2: Configure Claude Code with the new CLI command
+        print("\n2️⃣  Configuring Claude Code (~/.claude.json)...")
         try:
             success = self._configure_claude_desktop(args.force)
             if success:
                 print("✅ Configuration completed successfully")
                 print("\n🎉 MCP Gateway is ready to use!")
                 print("\nNext steps:")
-                print("1. Restart Claude Desktop")
+                print("1. Restart Claude Code (if running)")
                 print("2. Test the server: claude-mpm mcp server --test")
                 print("3. Check status: claude-mpm mcp status")
                 return 0
@@ -65,7 +65,11 @@ class MCPInstallCommands:
             return 1
 
     def _configure_claude_desktop(self, force=False):
-        """Configure Claude Desktop to use the MCP gateway via CLI command.
+        """Configure Claude Code to use the MCP gateway via CLI command.
+        
+        WHY: Claude Code reads MCP server configurations from ~/.claude.json
+        (not ~/.claude/settings.local.json). This method updates that file
+        to include the claude-mpm-gateway server configuration.
 
         Args:
             force: Whether to overwrite existing configuration
@@ -78,10 +82,10 @@ class MCPInstallCommands:
         from pathlib import Path
         from datetime import datetime
 
-        # Determine Claude Desktop config path based on platform
+        # Determine Claude Code config path
         config_path = self._get_claude_config_path()
         if not config_path:
-            print("❌ Could not determine Claude Desktop configuration path")
+            print("❌ Could not determine Claude Code configuration path")
             return False
 
         print(f"   Configuration path: {config_path}")
@@ -97,14 +101,27 @@ class MCPInstallCommands:
             print("❌ Could not find claude-mpm executable")
             return False
 
-        mcp_config = {
-            "command": claude_mpm_path,
-            "args": ["mcp", "server"],
-            "env": {
-                "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
-                "MCP_MODE": "production"
+        # Determine if we need to use -m claude_mpm or direct command
+        if claude_mpm_path.endswith(('python', 'python3', 'python.exe', 'python3.exe')):
+            # Using Python interpreter directly
+            mcp_config = {
+                "command": claude_mpm_path,
+                "args": ["-m", "claude_mpm", "mcp", "server"],
+                "env": {
+                    "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                    "MCP_MODE": "production"
+                }
+            }
+        else:
+            # Using installed claude-mpm command
+            mcp_config = {
+                "command": claude_mpm_path,
+                "args": ["mcp", "server"],
+                "env": {
+                    "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                    "MCP_MODE": "production"
+                }
             }
-        }
 
         # Update configuration
         if "mcpServers" not in config:
@@ -121,53 +138,68 @@ class MCPInstallCommands:
         return self._save_config(config, config_path)
 
     def _get_claude_config_path(self):
-        """Get the Claude Desktop configuration file path based on platform.
+        """Get the Claude Code configuration file path.
 
         Returns:
-            Path or None: Path to Claude Desktop config file
+            Path or None: Path to Claude Code config file
         """
-        import platform
         from pathlib import Path
 
-        system = platform.system()
-
-        if system == "Darwin":  # macOS
-            return Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
-        elif system == "Windows":
-            return Path.home() / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
-        elif system == "Linux":
-            return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
-        else:
-            print(f"❌ Unsupported platform: {system}")
-            return None
+        # Claude Code reads MCP server configurations from ~/.claude.json
+        # This is the actual file that Claude Code uses for MCP servers
+        # NOT ~/.claude/settings.local.json
+        return Path.home() / ".claude.json"
 
     def _find_claude_mpm_executable(self):
         """Find the claude-mpm executable path.
 
+        WHY: We need to find the installed claude-mpm command to use as the
+        MCP server command. This ensures we're using the properly installed
+        version with all dependencies, not a raw Python script.
+
+        DESIGN DECISION: We prioritize in this order:
+        1. System-installed claude-mpm (most reliable)
+        2. Virtual environment claude-mpm (development)
+        3. Python module invocation (fallback)
+
         Returns:
             str or None: Path to claude-mpm executable
         """
         import shutil
         import sys
+        import os
 
-        # Try to find claude-mpm in PATH
+        # 1. Try to find claude-mpm in PATH (system-wide or venv)
         claude_mpm_path = shutil.which("claude-mpm")
         if claude_mpm_path:
+            print(f"   Found claude-mpm: {claude_mpm_path}")
             return claude_mpm_path
 
-        # If not in PATH, try using python -m claude_mpm
-        # This works if claude-mpm is installed in the current Python environment
+        # 2. Check if we're in a virtual environment
+        if hasattr(sys, 'real_prefix') or (hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix):
+            # We're in a virtual environment
+            venv_bin = Path(sys.prefix) / ("Scripts" if sys.platform == "win32" else "bin")
+            venv_claude_mpm = venv_bin / "claude-mpm"
+            if venv_claude_mpm.exists():
+                print(f"   Found claude-mpm in venv: {venv_claude_mpm}")
+                return str(venv_claude_mpm)
+
+        # 3. Check if claude_mpm module is installed and use Python to run it
         try:
             import claude_mpm
-            return f"{sys.executable} -m claude_mpm"
+            # Return the Python executable - we'll handle the -m args separately
+            print(f"   Using Python module: {sys.executable} -m claude_mpm")
+            return sys.executable
         except ImportError:
             pass
 
-        # Last resort: try relative to current script
+        # 4. Last resort: check project's local venv (development mode)
         project_root = Path(__file__).parent.parent.parent.parent.parent
-        local_script = project_root / "scripts" / "claude-mpm"
-        if local_script.exists():
-            return str(local_script)
+        local_venv_bin = project_root / "venv" / ("Scripts" if sys.platform == "win32" else "bin")
+        local_claude_mpm = local_venv_bin / "claude-mpm"
+        if local_claude_mpm.exists():
+            print(f"   Found claude-mpm in project venv: {local_claude_mpm}")
+            return str(local_claude_mpm)
 
         return None
 

claude_mpm/cli/commands/mcp_server_commands.py

@@ -6,7 +6,7 @@ Extracted from mcp.py to reduce complexity and improve maintainability.
 
 import asyncio
 import os
-import subprocess
+import shutil
 import sys
 from pathlib import Path
 
@@ -25,8 +25,8 @@ class MCPServerCommands:
         implementation that Claude Desktop can communicate with.
         NOTE: MCP is for Claude Desktop's Code features.
 
-        DESIGN DECISION: We now use the wrapper script to ensure proper
-        environment setup regardless of how the server is invoked.
+        DESIGN DECISION: Run the server directly in the same process to ensure
+        Claude Desktop sees the correct command path, not a wrapper script.
         """
         self.logger.info("MCP server start command called")
 
@@ -54,22 +54,28 @@ class MCPServerCommands:
             
             # Find project root for paths
             project_root = Path(__file__).parent.parent.parent.parent.parent
-            wrapper_path = project_root / "scripts" / "mcp_wrapper.py"
+            
+            # Use the direct command, not the wrapper
+            import shutil
+            claude_mpm_path = shutil.which("claude-mpm")
+            if not claude_mpm_path:
+                # Fallback to current executable
+                claude_mpm_path = sys.executable.replace("python", "claude-mpm")
             
             print("\n   Add this to your Claude Desktop configuration:")
             print("   (~/Library/Application Support/Claude/claude_desktop_config.json on macOS)")
             print("\n   {")
             print('     "mcpServers": {')
             print('       "claude-mpm-gateway": {')
-            print(f'         "command": "{sys.executable}",')
-            print(f'         "args": ["{wrapper_path}"],')
+            print(f'         "command": "{claude_mpm_path}",')
+            print(f'         "args": ["mcp", "server"],')
             print(f'         "cwd": "{project_root}"')
             print('       }')
             print('     }')
             print('   }')
             print("\n3. Restart Claude Desktop to load the MCP server")
             print("\nTo test the server directly:")
-            print("   python scripts/mcp_wrapper.py")
+            print("   claude-mpm mcp server")
             print("\nTo check running MCP processes:")
             print("   python scripts/check_mcp_processes.py")
             print("\nFor more information, see:")
@@ -77,46 +83,35 @@ class MCPServerCommands:
 
             return 0
 
-        # Default behavior: Use the wrapper script for proper environment setup
+        # Default behavior: Run the server directly in this process
         if test_mode:
-            print("🧪 Starting MCP server in test mode...")
-            print("   This will run the server with stdio communication.")
-            print("   Press Ctrl+C to stop.\n")
+            print("🧪 Starting MCP server in test mode...", file=sys.stderr)
+            print("   This will run the server with stdio communication.", file=sys.stderr)
+            print("   Press Ctrl+C to stop.\n", file=sys.stderr)
 
         try:
-            # Instead of running directly, we should use the wrapper script
-            # for consistent environment setup
-            import subprocess
-            from pathlib import Path
-            
-            # Find the wrapper script
-            project_root = Path(__file__).parent.parent.parent.parent.parent
-            wrapper_script = project_root / "scripts" / "mcp_wrapper.py"
+            # Import and run the server directly
+            from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
             
-            if not wrapper_script.exists():
-                print(f"❌ Error: Wrapper script not found at {wrapper_script}", file=sys.stderr)
-                print("\nPlease ensure the wrapper script is installed.", file=sys.stderr)
-                return 1
+            # Set environment variable if in test mode
+            if test_mode:
+                os.environ["MCP_MODE"] = "test"
+            else:
+                os.environ["MCP_MODE"] = "production"
             
-            # Run the wrapper script
-            print(f"Starting MCP server via wrapper: {wrapper_script}", file=sys.stderr)
+            # Create and run the server
+            self.logger.info("Starting MCP Gateway Server directly...")
+            server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
             
-            # Use subprocess to run the wrapper
-            # This ensures proper environment setup
-            result = subprocess.run(
-                [sys.executable, str(wrapper_script)],
-                cwd=str(project_root),
-                env={**os.environ, "MCP_MODE": "test" if test_mode else "production"}
-            )
+            # Run the server asynchronously
+            await server.run()
             
-            return result.returncode
+            return 0
 
         except ImportError as e:
             self.logger.error(f"Failed to import MCP server: {e}")
             # Don't print to stdout as it would interfere with JSON-RPC protocol
             # Log to stderr instead
-            import sys
-
             print(
                 f"❌ Error: Could not import MCP server components: {e}", file=sys.stderr
             )
@@ -129,8 +124,6 @@ class MCPServerCommands:
             return 0
         except Exception as e:
             self.logger.error(f"Server error: {e}")
-            import sys
-
             print(f"❌ Error running server: {e}", file=sys.stderr)
             return 1