claude-mpm 4.3.12__py3-none-any.whl → 4.3.13__py3-none-any.whl

claude_mpm/services/framework_claude_md_generator/content_assembler.py

@@ -7,7 +7,7 @@ Assembles sections and applies template variable substitution.
 import hashlib
 import logging
 from collections import OrderedDict
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from claude_mpm.services.agents.management import AgentCapabilitiesGenerator
@@ -35,7 +35,7 @@ class ContentAssembler:
         Returns:
             str: 16-character hash of content
         """
-        timestamp = datetime.utcnow().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
         hash_obj = hashlib.sha256(timestamp.encode())
         return hash_obj.hexdigest()[:16]
 
@@ -176,7 +176,7 @@ class ContentAssembler:
         Returns:
             Dict: Metadata for header
         """
-        timestamp = datetime.utcnow().isoformat()
+        timestamp = datetime.now(timezone.utc).isoformat()
 
         return {
             "version": version,

claude_mpm/services/framework_claude_md_generator/section_generators/__init__.py

@@ -5,7 +5,7 @@ This module provides base classes and registry for section generators.
 """
 
 from abc import ABC, abstractmethod
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 
@@ -35,7 +35,7 @@ class BaseSectionGenerator(ABC):
 
     def get_timestamp(self) -> str:
         """Get current UTC timestamp."""
-        return datetime.utcnow().isoformat()
+        return datetime.now(timezone.utc).isoformat()
 
 
 class SectionGeneratorRegistry:

claude_mpm/services/hook_installer_service.py

@@ -24,7 +24,7 @@ class HookInstallerService:
         self.claude_dir = Path.home() / ".claude"
         self.settings_file = self.claude_dir / "settings.json"
 
-    def is_hooks_configured(self) -> bool:
+    def is_hooks_configured(self) -> bool:  # noqa: PLR0911
         """Check if hooks are configured in Claude settings.
 
         Returns:

claude_mpm/services/infrastructure/context_preservation.py

@@ -16,7 +16,7 @@ import gzip
 import json
 import shutil
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 import ijson  # For streaming JSON parsing
@@ -203,7 +203,9 @@ class ContextPreservationService(BaseService):
             await self._create_backup()
 
             # Load and filter conversations
-            cutoff_time = datetime.now().timestamp() - (keep_recent_days * 86400)
+            cutoff_time = datetime.now(timezone.utc).timestamp() - (
+                keep_recent_days * 86400
+            )
 
             with open(self.claude_json_path) as f:
                 data = json.load(f)
@@ -292,7 +294,7 @@ class ContextPreservationService(BaseService):
                 try:
                     if Path(file_path).exists():
                         valid_files.append(file_path)
-                except:
+                except Exception:
                     pass  # Invalid path
 
             return valid_files
@@ -516,7 +518,7 @@ class ContextPreservationService(BaseService):
     async def _create_backup(self) -> Path:
         """Create backup of Claude configuration."""
         try:
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_name = f"claude_backup_{timestamp}.json"
 
             # Compress if large

claude_mpm/services/infrastructure/daemon_manager.py

@@ -107,7 +107,7 @@ class SocketIODaemonManager:
             )
             if response.status_code == 200:
                 return response.json()
-        except:
+        except Exception:
             pass
         return None
 
@@ -265,7 +265,7 @@ class SocketIODaemonManager:
                 result = sock.connect_ex((self.host, self.port))
                 sock.close()
                 status_info["port_accessible"] = result == 0
-            except:
+            except Exception:
                 status_info["port_accessible"] = False
 
             # Check for conflicts

claude_mpm/services/infrastructure/logging.py

@@ -11,7 +11,7 @@ Part of TSK-0046: Service Layer Architecture Reorganization
 
 import json
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
 from claude_mpm.core.logger import get_logger
@@ -92,7 +92,7 @@ class LoggingService(SyncBaseService, IStructuredLogger):
 
         if self.structured_logging:
             log_entry = {
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "level": level,
                 "message": message,
                 "context": context,

claude_mpm/services/mcp_config_manager.py

@@ -10,14 +10,25 @@ MCP service installations.
 """
 
 import json
-import os
 import subprocess
+from datetime import datetime, timezone
+from enum import Enum
 from pathlib import Path
 from typing import Dict, Optional, Tuple
 
 from ..core.logger import get_logger
 
 
+class ConfigLocation(Enum):
+    """Enumeration of Claude configuration file locations."""
+
+    CLAUDE_JSON = Path.home() / ".claude.json"  # Primary Claude config
+    CLAUDE_DESKTOP = (
+        Path.home() / ".claude" / "claude_desktop_config.json"
+    )  # Not used by Claude Code
+    PROJECT_MCP = ".mcp.json"  # Project-level MCP config (deprecated)
+
+
 class MCPConfigManager:
     """Manages MCP service configurations with pipx preference."""
 
@@ -34,6 +45,9 @@ class MCPConfigManager:
         self.pipx_base = Path.home() / ".local" / "pipx" / "venvs"
         self.project_root = Path.cwd()
 
+        # Use the proper Claude config file location
+        self.claude_config_path = ConfigLocation.CLAUDE_JSON.value
+
     def detect_service_path(self, service_name: str) -> Optional[str]:
         """
         Detect the best path for an MCP service.
@@ -161,9 +175,7 @@ class MCPConfigManager:
             config["env"] = {}
         elif service_name == "mcp-browser":
             config["args"] = ["mcp"]
-            config["env"] = {
-                "MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")
-            }
+            config["env"] = {"MCP_BROWSER_HOME": str(Path.home() / ".mcp-browser")}
         elif service_name == "mcp-ticketer":
             config["args"] = ["mcp"]
         else:
@@ -172,9 +184,109 @@ class MCPConfigManager:
 
         return config
 
+    def ensure_mcp_services_configured(self) -> Tuple[bool, str]:
+        """
+        Ensure MCP services are configured in ~/.claude.json on startup.
+
+        This method checks if the core MCP services are configured in the
+        current project's mcpServers section and automatically adds them if missing.
+
+        Returns:
+            Tuple of (success, message)
+        """
+        updated = False
+        added_services = []
+        project_key = str(self.project_root)
+
+        # Load existing Claude config or create minimal structure
+        claude_config = {}
+        if self.claude_config_path.exists():
+            try:
+                with open(self.claude_config_path) as f:
+                    claude_config = json.load(f)
+            except Exception as e:
+                self.logger.error(f"Error reading {self.claude_config_path}: {e}")
+                return False, f"Failed to read Claude config: {e}"
+
+        # Ensure projects structure exists
+        if "projects" not in claude_config:
+            claude_config["projects"] = {}
+
+        if project_key not in claude_config["projects"]:
+            claude_config["projects"][project_key] = {
+                "allowedTools": [],
+                "history": [],
+                "mcpContextUris": [],
+                "mcpServers": {},
+                "enabledMcpjsonServers": [],
+                "disabledMcpjsonServers": [],
+                "hasTrustDialogAccepted": False,
+                "projectOnboardingSeenCount": 0,
+                "hasClaudeMdExternalIncludesApproved": False,
+                "hasClaudeMdExternalIncludesWarningShown": False,
+            }
+            updated = True
+
+        # Get the project's mcpServers section
+        project_config = claude_config["projects"][project_key]
+        if "mcpServers" not in project_config:
+            project_config["mcpServers"] = {}
+            updated = True
+
+        # Check each service and add if missing
+        for service_name in self.PIPX_SERVICES:
+            if service_name not in project_config["mcpServers"]:
+                # Try to detect and configure the service
+                service_path = self.detect_service_path(service_name)
+                if service_path:
+                    config = self.generate_service_config(service_name)
+                    if config:
+                        project_config["mcpServers"][service_name] = config
+                        added_services.append(service_name)
+                        updated = True
+                        self.logger.debug(
+                            f"Added MCP service to config: {service_name}"
+                        )
+                else:
+                    self.logger.debug(
+                        f"MCP service {service_name} not found for auto-configuration"
+                    )
+
+        # Write updated config if changes were made
+        if updated:
+            try:
+                # Create backup if file exists and is large (> 100KB)
+                if self.claude_config_path.exists():
+                    file_size = self.claude_config_path.stat().st_size
+                    if file_size > 100000:  # 100KB
+                        backup_path = self.claude_config_path.with_suffix(
+                            f".backup.{datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')}.json"
+                        )
+                        import shutil
+
+                        shutil.copy2(self.claude_config_path, backup_path)
+                        self.logger.debug(f"Created backup: {backup_path}")
+
+                # Write updated config
+                with open(self.claude_config_path, "w") as f:
+                    json.dump(claude_config, f, indent=2)
+
+                if added_services:
+                    message = (
+                        f"Auto-configured MCP services: {', '.join(added_services)}"
+                    )
+                    # Don't log here - let the caller handle logging to avoid duplicates
+                    return True, message
+                return True, "All MCP services already configured"
+            except Exception as e:
+                self.logger.error(f"Failed to write Claude config: {e}")
+                return False, f"Failed to write configuration: {e}"
+
+        return True, "All MCP services already configured"
+
     def update_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
         """
-        Update the .mcp.json configuration file.
+        Update the MCP configuration in ~/.claude.json.
 
         Args:
             force_pipx: If True, only use pipx installations
@@ -182,13 +294,27 @@ class MCPConfigManager:
         Returns:
             Tuple of (success, message)
         """
-        mcp_config_path = self.project_root / ".mcp.json"
+        # This method now delegates to ensure_mcp_services_configured
+        # since we're updating the Claude config directly
+        return self.ensure_mcp_services_configured()
+
+    def update_project_mcp_config(self, force_pipx: bool = True) -> Tuple[bool, str]:
+        """
+        Update the .mcp.json configuration file (legacy method).
+
+        Args:
+            force_pipx: If True, only use pipx installations
+
+        Returns:
+            Tuple of (success, message)
+        """
+        mcp_config_path = self.project_root / ConfigLocation.PROJECT_MCP.value
 
         # Load existing config if it exists
         existing_config = {}
         if mcp_config_path.exists():
             try:
-                with open(mcp_config_path, "r") as f:
+                with open(mcp_config_path) as f:
                     existing_config = json.load(f)
             except Exception as e:
                 self.logger.error(f"Error reading existing config: {e}")
@@ -203,12 +329,11 @@ class MCPConfigManager:
                 new_config["mcpServers"][service_name] = config
             elif force_pipx:
                 missing_services.append(service_name)
-            else:
-                # Keep existing config if not forcing pipx
-                if service_name in existing_config.get("mcpServers", {}):
-                    new_config["mcpServers"][service_name] = existing_config[
-                        "mcpServers"
-                    ][service_name]
+            # Keep existing config if not forcing pipx
+            elif service_name in existing_config.get("mcpServers", {}):
+                new_config["mcpServers"][service_name] = existing_config["mcpServers"][
+                    service_name
+                ]
 
         # Add any additional services from existing config
         for service_name, config in existing_config.get("mcpServers", {}).items():
@@ -223,8 +348,7 @@ class MCPConfigManager:
             if missing_services:
                 message = f"Updated .mcp.json. Missing services (install via pipx): {', '.join(missing_services)}"
                 return True, message
-            else:
-                return True, "Successfully updated .mcp.json with pipx paths"
+            return True, "Successfully updated .mcp.json with pipx paths"
         except Exception as e:
             return False, f"Failed to update .mcp.json: {e}"
 
@@ -235,23 +359,45 @@ class MCPConfigManager:
         Returns:
             Dict mapping service names to availability status
         """
-        mcp_config_path = self.project_root / ".mcp.json"
-        if not mcp_config_path.exists():
+        project_key = str(self.project_root)
+
+        # Check Claude config
+        if not self.claude_config_path.exists():
+            # Also check legacy .mcp.json
+            mcp_config_path = self.project_root / ConfigLocation.PROJECT_MCP.value
+            if mcp_config_path.exists():
+                try:
+                    with open(mcp_config_path) as f:
+                        config = json.load(f)
+                        results = {}
+                        for service_name, service_config in config.get(
+                            "mcpServers", {}
+                        ).items():
+                            command_path = service_config.get("command", "")
+                            results[service_name] = Path(command_path).exists()
+                        return results
+                except Exception:
+                    pass
             return {}
 
         try:
-            with open(mcp_config_path, "r") as f:
-                config = json.load(f)
+            with open(self.claude_config_path) as f:
+                claude_config = json.load(f)
+
+            # Get project's MCP servers
+            if "projects" in claude_config and project_key in claude_config["projects"]:
+                mcp_servers = claude_config["projects"][project_key].get(
+                    "mcpServers", {}
+                )
+                results = {}
+                for service_name, service_config in mcp_servers.items():
+                    command_path = service_config.get("command", "")
+                    results[service_name] = Path(command_path).exists()
+                return results
         except Exception as e:
             self.logger.error(f"Error reading config: {e}")
-            return {}
 
-        results = {}
-        for service_name, service_config in config.get("mcpServers", {}).items():
-            command_path = service_config.get("command", "")
-            results[service_name] = Path(command_path).exists()
-
-        return results
+        return {}
 
     def install_missing_services(self) -> Tuple[bool, str]:
         """
@@ -274,7 +420,7 @@ class MCPConfigManager:
         for service_name in missing:
             try:
                 self.logger.info(f"Installing {service_name} via pipx...")
-                result = subprocess.run(
+                subprocess.run(
                     ["pipx", "install", service_name],
                     capture_output=True,
                     text=True,
@@ -288,7 +434,6 @@ class MCPConfigManager:
 
         if failed:
             return False, f"Failed to install: {', '.join(failed)}"
-        elif installed:
+        if installed:
             return True, f"Successfully installed: {', '.join(installed)}"
-        else:
-            return True, "No services needed installation"
+        return True, "No services needed installation"

claude_mpm/services/mcp_gateway/__init__.py

@@ -26,7 +26,7 @@ __version__ = "0.1.0"
 
 
 # Lazy imports to prevent circular dependencies and improve startup performance
-def __getattr__(name):
+def __getattr__(name):  # noqa: PLR0911
     """Lazy import mechanism for MCP Gateway components."""
 
     # Core interfaces and base classes

claude_mpm/services/mcp_gateway/auto_configure.py

@@ -20,7 +20,7 @@ DESIGN DECISIONS:
 import json
 import os
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -144,7 +144,7 @@ class MCPAutoConfigurator:
         prefs = {
             "asked": True,
             "choice": choice,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
         }
 
         try:
@@ -266,7 +266,7 @@ class MCPAutoConfigurator:
     def _create_backup(self) -> Optional[Path]:
         """Create backup of existing configuration."""
         try:
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
             backup_path = self.claude_config_path.with_suffix(
                 f".backup.{timestamp}.json"
             )

claude_mpm/services/mcp_gateway/config/config_loader.py

@@ -143,7 +143,7 @@ class MCPConfigLoader:
                 import json
 
                 current[key] = json.loads(env_value)
-            except:
+            except Exception:
                 # Fall back to string value
                 current[key] = env_value
 

claude_mpm/services/mcp_gateway/config/configuration.py

@@ -225,7 +225,7 @@ class MCPConfiguration(BaseMCPService, IMCPConfiguration):
                     import json
 
                     current[key] = json.loads(env_value)
-                except:
+                except Exception:
                     # Fall back to string value
                     current[key] = env_value
 

claude_mpm/services/mcp_gateway/core/base.py

@@ -279,10 +279,10 @@ class BaseMCPService(BaseService):
             healthy: Whether service is healthy
             details: Additional health details
         """
-        from datetime import datetime
+        from datetime import datetime, timezone
 
         self._health_status["healthy"] = healthy
-        self._health_status["last_check"] = datetime.now().isoformat()
+        self._health_status["last_check"] = datetime.now(timezone.utc).isoformat()
 
         if details:
             self._health_status["details"].update(details)

claude_mpm/services/mcp_gateway/main.py

@@ -213,21 +213,35 @@ class MCPGatewayOrchestrator:
                 try:
                     self.logger.info("Initializing external MCP services...")
                     self.external_services = ExternalMCPServiceManager()
-                    external_services = await self.external_services.initialize_services()
+                    external_services = (
+                        await self.external_services.initialize_services()
+                    )
 
                     if external_services and self.registry:
                         for service in external_services:
                             try:
-                                if self.registry.register_tool(service, category="external"):
-                                    self.logger.info(f"Registered external service: {service.service_name}")
+                                if self.registry.register_tool(
+                                    service, category="external"
+                                ):
+                                    self.logger.info(
+                                        f"Registered external service: {service.service_name}"
+                                    )
                                 else:
-                                    self.logger.warning(f"Failed to register external service: {service.service_name}")
+                                    self.logger.warning(
+                                        f"Failed to register external service: {service.service_name}"
+                                    )
                             except Exception as e:
-                                self.logger.warning(f"Error registering {service.service_name}: {e}")
+                                self.logger.warning(
+                                    f"Error registering {service.service_name}: {e}"
+                                )
 
-                    self.logger.info(f"Initialized {len(external_services)} external MCP services")
+                    self.logger.info(
+                        f"Initialized {len(external_services)} external MCP services"
+                    )
                 except Exception as e:
-                    self.logger.warning(f"Failed to initialize external MCP services: {e}")
+                    self.logger.warning(
+                        f"Failed to initialize external MCP services: {e}"
+                    )
                     self.external_services = None
 
             # Initialize communication handler with fallback

claude_mpm/services/mcp_gateway/registry/tool_registry.py

@@ -11,7 +11,7 @@ Part of ISS-0035: MCP Server Implementation - Core Server and Tool Registry
 import asyncio
 import re
 import traceback
-from datetime import datetime
+from datetime import datetime, timezone
 from threading import RLock
 from typing import Any, Dict, List, Optional, Set
 
@@ -159,9 +159,9 @@ class ToolRegistry(BaseMCPService, IMCPToolRegistry):
 
                 # Update metrics
                 self._metrics["total_tools"] = len(self._adapters)
-                self._metrics["registration_time"][
-                    tool_name
-                ] = datetime.now().isoformat()
+                self._metrics["registration_time"][tool_name] = datetime.now(
+                    timezone.utc
+                ).isoformat()
                 self._metrics["invocations"][tool_name] = 0
                 self._metrics["errors"][tool_name] = 0
 
@@ -272,7 +272,7 @@ class ToolRegistry(BaseMCPService, IMCPToolRegistry):
         error handling, metrics tracking, and validation.
         """
         tool_name = invocation.tool_name
-        start_time = datetime.now()
+        start_time = datetime.now(timezone.utc)
 
         try:
             self.log_info(f"Invoking tool: {tool_name}")
@@ -300,7 +300,7 @@ class ToolRegistry(BaseMCPService, IMCPToolRegistry):
             result = await adapter.invoke(invocation)
 
             # Calculate execution time
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
             result.execution_time = execution_time
 
             # Update metrics
@@ -308,7 +308,9 @@ class ToolRegistry(BaseMCPService, IMCPToolRegistry):
                 self._metrics["invocations"][tool_name] = (
                     self._metrics["invocations"].get(tool_name, 0) + 1
                 )
-                self._metrics["last_invocation"][tool_name] = datetime.now().isoformat()
+                self._metrics["last_invocation"][tool_name] = datetime.now(
+                    timezone.utc
+                ).isoformat()
 
                 if not result.success:
                     self._metrics["errors"][tool_name] = (
@@ -331,7 +333,7 @@ class ToolRegistry(BaseMCPService, IMCPToolRegistry):
                     self._metrics["errors"].get(tool_name, 0) + 1
                 )
 
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
 
             return MCPToolResult(
                 success=False, error=error_msg, execution_time=execution_time

claude_mpm/services/mcp_gateway/server/mcp_gateway.py

@@ -16,7 +16,7 @@ import asyncio
 import contextlib
 import json
 import traceback
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional, Union
 
 # Import from the official MCP package
@@ -148,7 +148,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
             invocation = MCPToolInvocation(
                 tool_name=name,
                 parameters=arguments,
-                request_id=f"req_{datetime.now().timestamp()}",
+                request_id=f"req_{datetime.now(timezone.utc).timestamp()}",
             )
 
             try:
@@ -212,7 +212,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
                 self.log_warning("No tool registry set - server will have no tools")
 
             # Initialize metrics
-            self._metrics["start_time"] = datetime.now().isoformat()
+            self._metrics["start_time"] = datetime.now(timezone.utc).isoformat()
 
             # Update capabilities based on registry
             if self._tool_registry:
@@ -287,7 +287,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
         try:
             # Update metrics
             self._metrics["requests_handled"] += 1
-            self._metrics["last_request_time"] = datetime.now().isoformat()
+            self._metrics["last_request_time"] = datetime.now(timezone.utc).isoformat()
 
             # Extract request details
             method = request.get("method", "")

claude_mpm/services/mcp_gateway/server/stdio_handler.py

@@ -139,7 +139,7 @@ class StdioHandler(BaseMCPService, IMCPCommunication):
             self._metrics["errors"] += 1
             raise
 
-    async def receive_message(self) -> Optional[Dict[str, Any]]:
+    async def receive_message(self) -> Optional[Dict[str, Any]]:  # noqa: PLR0911
         """
         Receive a message from the MCP client via stdin.