claude-mpm 3.7.8__py3-none-any.whl → 3.9.0__py3-none-any.whl

claude_mpm/services/framework_claude_md_generator/__init__.py

@@ -24,8 +24,14 @@ class FrameworkClaudeMdGenerator:
     This is the main facade class that coordinates all the submodules.
     """
     
-    def __init__(self):
-        """Initialize the generator with current framework version."""
+    def __init__(self, target_filename: str = "INSTRUCTIONS.md"):
+        """
+        Initialize the generator with current framework version.
+        
+        Args:
+            target_filename: Target filename for deployment (default: "INSTRUCTIONS.md")
+                           Can be set to "CLAUDE.md" for legacy compatibility
+        """
         # Initialize managers
         self.version_manager = VersionManager()
         self.validator = ContentValidator()
@@ -35,7 +41,8 @@ class FrameworkClaudeMdGenerator:
         # Initialize deployment manager with dependencies
         self.deployment_manager = DeploymentManager(
             self.version_manager, 
-            self.validator
+            self.validator,
+            target_filename=target_filename
         )
         
         # Get framework version

claude_mpm/services/framework_claude_md_generator/deployment_manager.py

@@ -6,7 +6,7 @@ Handles deployment operations to parent directories.
 
 from pathlib import Path
 from typing import Tuple, Optional
-from datetime import datetime
+from datetime import datetime, timezone
 from .version_manager import VersionManager
 from .content_validator import ContentValidator
 
@@ -17,16 +17,20 @@ from ...utils.framework_detection import is_framework_source_directory
 class DeploymentManager:
     """Manages deployment of framework CLAUDE.md to parent directories."""
     
-    def __init__(self, version_manager: VersionManager, validator: ContentValidator):
+    def __init__(self, version_manager: VersionManager, validator: ContentValidator, 
+                 target_filename: str = "INSTRUCTIONS.md"):
         """
         Initialize deployment manager.
         
         Args:
             version_manager: Version management instance
             validator: Content validator instance
+            target_filename: Target filename for deployment (default: "INSTRUCTIONS.md")
+                           Can be set to "CLAUDE.md" for legacy compatibility
         """
         self.version_manager = version_manager
         self.validator = validator
+        self.target_filename = target_filename
     
     def deploy_to_parent(self, 
                         content: str,
@@ -53,9 +57,8 @@ class DeploymentManager:
         if is_framework:
             return True, f"Skipping deployment - detected framework source directory (markers: {', '.join(markers)})"
         
-        # Use INSTRUCTIONS.md as primary, with CLAUDE.md as fallback
-        target_file = parent_path / "INSTRUCTIONS.md"
-        # TODO: Make this configurable via parameter
+        # Use configured target filename
+        target_file = parent_path / self.target_filename
         
         # Check if content contains template variables that need processing
         if '{{capabilities-list}}' in content:
@@ -115,10 +118,10 @@ class DeploymentManager:
         Returns:
             Tuple of (needed, reason)
         """
-        target_file = parent_path / "CLAUDE.md"
+        target_file = parent_path / self.target_filename
         
         if not target_file.exists():
-            return True, "CLAUDE.md does not exist"
+            return True, f"{self.target_filename} does not exist"
         
         try:
             with open(target_file, 'r') as f:
@@ -134,7 +137,7 @@ class DeploymentManager:
     
     def backup_existing(self, parent_path: Path) -> Optional[Path]:
         """
-        Create a backup of existing CLAUDE.md before deployment.
+        Create a backup of existing target file before deployment.
         
         Args:
             parent_path: Path to parent directory
@@ -142,14 +145,14 @@ class DeploymentManager:
         Returns:
             Path to backup file if created, None otherwise
         """
-        target_file = parent_path / "CLAUDE.md"
+        target_file = parent_path / self.target_filename
         
         if not target_file.exists():
             return None
         
         # Create backup filename with timestamp
-        timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
-        backup_file = parent_path / f"CLAUDE.md.backup.{timestamp}"
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+        backup_file = parent_path / f"{self.target_filename}.backup.{timestamp}"
         
         try:
             import shutil

claude_mpm/services/framework_claude_md_generator/section_generators/todo_task_tools.py

@@ -45,31 +45,31 @@ Task(description="[task description]", subagent_type="[agent-type]")
 
 **Valid subagent_type values (use lowercase format for Claude Code compatibility):**
 
-**Required lowercase format (Claude Code expects these exact values):**
-- `subagent_type="research"` - For investigation and analysis
+**Required format (Claude Code expects these exact values from deployed agent YAML names):**
+- `subagent_type="research-agent"` - For investigation and analysis
 - `subagent_type="engineer"` - For coding and implementation
-- `subagent_type="qa"` - For testing and quality assurance
-- `subagent_type="documentation"` - For docs and guides
-- `subagent_type="security"` - For security assessments
-- `subagent_type="ops"` - For deployment and infrastructure
-- `subagent_type="version_control"` - For git and version management (use underscore, not hyphen)
-- `subagent_type="data_engineer"` - For data processing and APIs (use underscore, not hyphen)
+- `subagent_type="qa-agent"` - For testing and quality assurance
+- `subagent_type="documentation-agent"` - For docs and guides
+- `subagent_type="security-agent"` - For security assessments
+- `subagent_type="ops-agent"` - For deployment and infrastructure
+- `subagent_type="version-control"` - For git and version management
+- `subagent_type="data-engineer"` - For data processing and APIs
 - `subagent_type="pm"` - For project management coordination
 - `subagent_type="test_integration"` - For integration testing
 
-**Note:** Claude Code's Task tool requires exact lowercase agent names. Capitalized formats like "Research" or "Engineer" will be rejected with an error.
+**Note:** Claude Code's Task tool requires exact agent names as defined in the deployed agent YAML frontmatter. The names must match exactly - including hyphens where specified.
 
-**Examples of Proper Task Tool Usage (use lowercase format only):**
-- ✅ `Task(description="Update framework documentation", subagent_type="documentation")`
-- ✅ `Task(description="Execute test suite validation", subagent_type="qa")`
-- ✅ `Task(description="Create feature branch and sync", subagent_type="version_control")` (use underscore)
-- ✅ `Task(description="Investigate performance patterns", subagent_type="research")`
+**Examples of Proper Task Tool Usage (must match deployed agent YAML names):**
+- ✅ `Task(description="Update framework documentation", subagent_type="documentation-agent")`
+- ✅ `Task(description="Execute test suite validation", subagent_type="qa-agent")`
+- ✅ `Task(description="Create feature branch and sync", subagent_type="version-control")`
+- ✅ `Task(description="Investigate performance patterns", subagent_type="research-agent")`
 - ✅ `Task(description="Implement authentication system", subagent_type="engineer")`
-- ✅ `Task(description="Configure database and optimize queries", subagent_type="data_engineer")` (use underscore)
+- ✅ `Task(description="Configure database and optimize queries", subagent_type="data-engineer")`
 - ✅ `Task(description="Coordinate project tasks", subagent_type="pm")`
-- ❌ `Task(description="Analyze code patterns", subagent_type="Research")` (WRONG - will be rejected)
-- ❌ `Task(description="Update API docs", subagent_type="Documentation")` (WRONG - will be rejected)
-- ❌ `Task(description="Create release tags", subagent_type="Version Control")` (WRONG - will be rejected)
+- ❌ `Task(description="Analyze code patterns", subagent_type="research")` (WRONG - missing '-agent' suffix)
+- ❌ `Task(description="Update API docs", subagent_type="documentation")` (WRONG - missing '-agent' suffix)
+- ❌ `Task(description="Create release tags", subagent_type="version_control")` (WRONG - should be 'version-control')
 
 ### 🚨 MANDATORY: THREE SHORTCUT COMMANDS
 
@@ -98,11 +98,11 @@ Task(description="[task description]", subagent_type="[agent-type]")
 - ☐ [Data Engineer] Validate data integrity and verify API connectivity
 - ☐ [Version Control] Apply semantic version bump and create release tags
 
-# Corresponding Task Tool delegations (use lowercase with underscores):
-Task(description="Generate changelog and analyze version impact", subagent_type="documentation")
-Task(description="Execute full test suite and quality validation", subagent_type="qa")
-Task(description="Validate data integrity and verify API connectivity", subagent_type="data_engineer")
-Task(description="Apply semantic version bump and create release tags", subagent_type="version_control")
+# Corresponding Task Tool delegations (must match deployed agent names):
+Task(description="Generate changelog and analyze version impact", subagent_type="documentation-agent")
+Task(description="Execute full test suite and quality validation", subagent_type="qa-agent")
+Task(description="Validate data integrity and verify API connectivity", subagent_type="data-engineer")
+Task(description="Apply semantic version bump and create release tags", subagent_type="version-control")
 
 # Update TodoWrite status based on agent completions
 ```

claude_mpm/services/framework_claude_md_generator.py

@@ -19,6 +19,7 @@ from typing import Dict, Optional, Any, List, Tuple, Callable
 from dataclasses import dataclass, field
 
 from claude_mpm.core.config_paths import ConfigPaths
+from claude_mpm.core.constants import SystemLimits
 
 logger = logging.getLogger(__name__)
 
@@ -450,8 +451,8 @@ class FrameworkClaudeMdGenerator:
         suggestions = []
         
         # Check minimum length
-        if len(content) < 1000:
-            errors.append("Content seems too short")
+        if len(content) < SystemLimits.MIN_CONTENT_LENGTH:
+            errors.append(f"Content seems too short (minimum {SystemLimits.MIN_CONTENT_LENGTH} characters)")
         
         # Check for required sections
         required_sections = [

claude_mpm/services/health_monitor.py

@@ -27,6 +27,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Callable, Union
 import json
 import socket
+from claude_mpm.core.constants import ResourceLimits, TimeoutConfig
 
 try:
     import psutil
@@ -196,7 +197,7 @@ class ProcessResourceChecker(HealthChecker):
             
             # CPU usage
             try:
-                cpu_percent = self.process.cpu_percent(interval=0.1)
+                cpu_percent = self.process.cpu_percent(interval=TimeoutConfig.CPU_SAMPLE_INTERVAL)
                 cpu_status = HealthStatus.HEALTHY
                 if cpu_percent > self.cpu_threshold:
                     cpu_status = HealthStatus.WARNING if cpu_percent < self.cpu_threshold * 1.2 else HealthStatus.CRITICAL
@@ -219,7 +220,7 @@ class ProcessResourceChecker(HealthChecker):
             # Memory usage
             try:
                 memory_info = self.process.memory_info()
-                memory_mb = memory_info.rss / (1024 * 1024)
+                memory_mb = memory_info.rss / ResourceLimits.BYTES_TO_MB
                 memory_status = HealthStatus.HEALTHY
                 if memory_mb > self.memory_threshold_mb:
                     memory_status = HealthStatus.WARNING if memory_mb < self.memory_threshold_mb * 1.2 else HealthStatus.CRITICAL
@@ -234,7 +235,7 @@ class ProcessResourceChecker(HealthChecker):
                 
                 metrics.append(HealthMetric(
                     name="memory_vms_mb",
-                    value=round(memory_info.vms / (1024 * 1024), 2),
+                    value=round(memory_info.vms / ResourceLimits.BYTES_TO_MB, 2),
                     status=HealthStatus.HEALTHY,
                     unit="MB"
                 ))

claude_mpm/services/hook_service.py

@@ -16,7 +16,7 @@ import time
 from datetime import datetime
 
 from claude_mpm.core.config import Config
-from claude_mpm.core.logger import get_logger
+from claude_mpm.core.logging_config import get_logger, log_operation
 from claude_mpm.hooks.base_hook import (
     BaseHook,
     PreDelegationHook,
@@ -25,9 +25,10 @@ from claude_mpm.hooks.base_hook import (
     HookResult,
     HookType
 )
+from claude_mpm.core.interfaces import HookServiceInterface
 
 
-class HookService:
+class HookService(HookServiceInterface):
     """Service for managing and executing hooks in the delegation workflow.
     
     WHY: Provides a centralized place to register and execute hooks, ensuring
@@ -47,7 +48,7 @@ class HookService:
             config: Optional configuration object for controlling hook behavior
         """
         self.config = config or Config()
-        self.logger = get_logger("hook_service")
+        self.logger = get_logger(__name__)
         
         # Separate lists for different hook types for performance
         self.pre_delegation_hooks: List[PreDelegationHook] = []
@@ -359,4 +360,63 @@ class HookService:
                 return True
                 
         self.logger.warning(f"Hook not found: {hook_name}")
-        return False
+        return False
+    
+    # ================================================================================
+    # Interface Adapter Methods
+    # ================================================================================
+    # These methods are added to comply with HookServiceInterface
+    
+    def get_registered_hooks(self) -> Dict[str, List[Any]]:
+        """Get all registered hooks by type.
+        
+        WHY: This method provides interface compliance by exposing the
+        registered hooks for inspection and debugging purposes.
+        
+        Returns:
+            Dictionary mapping hook types to lists of hooks
+        """
+        return {
+            "pre_delegation": [
+                {
+                    "name": hook.name,
+                    "priority": hook.priority,
+                    "enabled": hook.enabled,
+                    "type": "pre_delegation"
+                }
+                for hook in self.pre_delegation_hooks
+            ],
+            "post_delegation": [
+                {
+                    "name": hook.name,
+                    "priority": hook.priority,
+                    "enabled": hook.enabled,
+                    "type": "post_delegation"
+                }
+                for hook in self.post_delegation_hooks
+            ]
+        }
+    
+    def clear_hooks(self, hook_type: Optional[str] = None) -> None:
+        """Clear registered hooks.
+        
+        WHY: This method provides interface compliance by allowing bulk
+        removal of hooks, useful for testing and cleanup scenarios.
+        
+        Args:
+            hook_type: Optional specific hook type to clear, or None for all
+        """
+        if hook_type is None or hook_type == "pre_delegation":
+            count = len(self.pre_delegation_hooks)
+            self.pre_delegation_hooks.clear()
+            if count > 0:
+                self.logger.info(f"Cleared {count} pre-delegation hooks")
+        
+        if hook_type is None or hook_type == "post_delegation":
+            count = len(self.post_delegation_hooks)
+            self.post_delegation_hooks.clear()
+            if count > 0:
+                self.logger.info(f"Cleared {count} post-delegation hooks")
+        
+        if hook_type and hook_type not in ["pre_delegation", "post_delegation"]:
+            self.logger.warning(f"Unknown hook type: {hook_type}")

claude_mpm/services/infrastructure/__init__.py

@@ -0,0 +1,21 @@
+"""
+Infrastructure Services Module
+=============================
+
+This module contains infrastructure-related services including
+logging, monitoring, and system health management.
+
+Part of TSK-0046: Service Layer Architecture Reorganization
+
+Services:
+- LoggingService: Centralized logging with structured output
+- HealthMonitor: System health monitoring and alerting
+"""
+
+from .logging import LoggingService
+from .monitoring import HealthMonitor
+
+__all__ = [
+    'LoggingService',
+    'HealthMonitor',
+]

claude_mpm/services/infrastructure/logging.py

@@ -0,0 +1,202 @@
+"""
+Logging Service for Claude MPM Framework
+========================================
+
+This module provides centralized logging services and utilities.
+
+Part of TSK-0046: Service Layer Architecture Reorganization
+"""
+
+from typing import Any, Dict, Optional, List
+from pathlib import Path
+import logging
+import json
+from datetime import datetime
+
+from claude_mpm.services.core import SyncBaseService, ILoggingService
+from claude_mpm.utils.logger import get_logger
+
+
+class LoggingService(SyncBaseService, ILoggingService):
+    """
+    Centralized logging service for the Claude MPM framework.
+    
+    This service provides:
+    - Structured logging with JSON output
+    - Log rotation and archival
+    - Performance metrics logging
+    - Audit trail capabilities
+    """
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize logging service.
+        
+        Args:
+            config: Logging configuration
+        """
+        super().__init__("LoggingService", config)
+        self.log_dir = Path(self.get_config('log_dir', '.claude-mpm/logs'))
+        self.log_level = self.get_config('log_level', 'INFO')
+        self.structured_logging = self.get_config('structured_logging', True)
+        self._log_handlers = []
+    
+    def initialize(self) -> bool:
+        """Initialize the logging service."""
+        try:
+            # Create log directory if it doesn't exist
+            self.log_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Set up log rotation if configured
+            if self.get_config('enable_rotation', True):
+                self._setup_rotation()
+            
+            # Set up structured logging if enabled
+            if self.structured_logging:
+                self._setup_structured_logging()
+            
+            self._initialized = True
+            self.log_info("Logging service initialized successfully")
+            return True
+            
+        except Exception as e:
+            self.log_error(f"Failed to initialize logging service: {e}")
+            return False
+    
+    def shutdown(self) -> None:
+        """Shutdown the logging service."""
+        try:
+            # Flush all handlers
+            for handler in self._log_handlers:
+                handler.flush()
+                handler.close()
+            
+            self._log_handlers.clear()
+            self._shutdown = True
+            self.log_info("Logging service shutdown successfully")
+            
+        except Exception as e:
+            self.log_error(f"Error during logging service shutdown: {e}")
+    
+    def log(self, level: str, message: str, **context) -> None:
+        """
+        Log a message with context.
+        
+        Args:
+            level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            message: Log message
+            **context: Additional context to include
+        """
+        logger = get_logger(context.get('component', 'default'))
+        
+        if self.structured_logging:
+            log_entry = {
+                'timestamp': datetime.utcnow().isoformat(),
+                'level': level,
+                'message': message,
+                'context': context
+            }
+            message = json.dumps(log_entry)
+        
+        log_method = getattr(logger, level.lower(), logger.info)
+        log_method(message)
+    
+    def log_performance(self, operation: str, duration: float, **metrics) -> None:
+        """
+        Log performance metrics.
+        
+        Args:
+            operation: Name of the operation
+            duration: Duration in seconds
+            **metrics: Additional performance metrics
+        """
+        self.log('INFO', f"Performance: {operation}", 
+                operation=operation, 
+                duration_ms=duration * 1000,
+                **metrics)
+    
+    def log_audit(self, action: str, user: str, **details) -> None:
+        """
+        Log an audit event.
+        
+        Args:
+            action: Action performed
+            user: User who performed the action
+            **details: Additional audit details
+        """
+        self.log('INFO', f"Audit: {action} by {user}",
+                audit=True,
+                action=action,
+                user=user,
+                **details)
+    
+    def get_logs(self, level: Optional[str] = None, 
+                 component: Optional[str] = None,
+                 limit: int = 100) -> List[Dict[str, Any]]:
+        """
+        Retrieve recent logs.
+        
+        Args:
+            level: Filter by log level
+            component: Filter by component
+            limit: Maximum number of logs to return
+            
+        Returns:
+            List of log entries
+        """
+        # This would typically read from log files or a log aggregation service
+        # For now, return empty list as placeholder
+        return []
+    
+    def _setup_rotation(self) -> None:
+        """Set up log rotation."""
+        from logging.handlers import RotatingFileHandler
+        
+        max_bytes = self.get_config('max_bytes', 10 * 1024 * 1024)  # 10MB
+        backup_count = self.get_config('backup_count', 5)
+        
+        handler = RotatingFileHandler(
+            self.log_dir / 'claude_mpm.log',
+            maxBytes=max_bytes,
+            backupCount=backup_count
+        )
+        
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        
+        self._log_handlers.append(handler)
+        logging.getLogger().addHandler(handler)
+    
+    def _setup_structured_logging(self) -> None:
+        """Set up structured JSON logging."""
+        import logging.config
+        
+        config = {
+            'version': 1,
+            'disable_existing_loggers': False,
+            'formatters': {
+                'json': {
+                    'class': 'pythonjsonlogger.jsonlogger.JsonFormatter',
+                    'format': '%(asctime)s %(name)s %(levelname)s %(message)s'
+                }
+            },
+            'handlers': {
+                'json_file': {
+                    'class': 'logging.FileHandler',
+                    'filename': str(self.log_dir / 'structured.json'),
+                    'formatter': 'json'
+                }
+            },
+            'root': {
+                'handlers': ['json_file'],
+                'level': self.log_level
+            }
+        }
+        
+        try:
+            logging.config.dictConfig(config)
+        except ImportError:
+            # If pythonjsonlogger is not available, fall back to regular logging
+            self.log_warning("pythonjsonlogger not available, using standard logging")