claude-mpm 4.3.5__py3-none-any.whl → 4.3.11__py3-none-any.whl

claude_mpm/cli/commands/run.py

@@ -15,7 +15,7 @@ DESIGN DECISIONS:
 
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 from ...constants import LogLevel
@@ -522,7 +522,7 @@ class RunCommand(BaseCommand):
             # Update session usage
             session = session_manager.load_session(resume_session_id)
             if session:
-                session.last_used = datetime.now().isoformat()
+                session.last_used = datetime.now(timezone.utc).isoformat()
                 session.use_count += 1
                 session_manager.save_session(session)
         else:
@@ -936,7 +936,7 @@ def run_session_legacy(args):
         # Update session usage
         session = session_manager.load_session(resume_session_id)
         if session:
-            session.last_used = datetime.now().isoformat()
+            session.last_used = datetime.now(timezone.utc).isoformat()
             session.use_count += 1
             session_manager.save_session(session)
     else:

claude_mpm/cli/startup_logging.py

@@ -18,7 +18,7 @@ import logging
 import shutil
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -339,14 +339,27 @@ class StartupStatusLogger:
 
     def _check_socketio_dependencies(self) -> Dict[str, Any]:
         """Check if Socket.IO dependencies are available."""
+        import importlib.util
+
         result = {"available": False, "error": None}
 
         try:
-            import aiohttp
-            import engineio
-            import socketio
+            # Check for socketio dependencies without importing them
+            aiohttp_spec = importlib.util.find_spec("aiohttp")
+            engineio_spec = importlib.util.find_spec("engineio")
+            socketio_spec = importlib.util.find_spec("socketio")
 
-            result["available"] = True
+            if aiohttp_spec and engineio_spec and socketio_spec:
+                result["available"] = True
+            else:
+                missing = []
+                if not aiohttp_spec:
+                    missing.append("aiohttp")
+                if not engineio_spec:
+                    missing.append("engineio")
+                if not socketio_spec:
+                    missing.append("socketio")
+                result["error"] = f"Missing dependencies: {', '.join(missing)}"
         except ImportError as e:
             result["error"] = f"Missing dependencies: {e}"
         except Exception as e:
@@ -493,7 +506,7 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     log_dir.mkdir(parents=True, exist_ok=True)
 
     # Generate timestamp for log file
-    timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H-%M-%S")
     log_file = log_dir / f"startup-{timestamp}.log"
 
     # Create file handler with detailed formatting
@@ -516,7 +529,7 @@ def setup_startup_logging(project_root: Optional[Path] = None) -> Path:
     # Log startup header
     logger = get_logger("startup")
     logger.info("=" * 60)
-    logger.info(f"Claude MPM Startup - {datetime.now().isoformat()}")
+    logger.info(f"Claude MPM Startup - {datetime.now(timezone.utc).isoformat()}")
     logger.info(f"Log file: {log_file}")
     logger.info("=" * 60)
 

claude_mpm/hooks/instruction_reinforcement.py

@@ -0,0 +1,295 @@
+"""
+Instruction Reinforcement Hook for PM Delegation Compliance
+
+This hook monitors PM behavior for delegation violations and provides
+escalating warnings when the PM attempts to implement instead of delegate.
+"""
+
+import logging
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class ViolationType(Enum):
+    """Types of PM delegation violations"""
+
+    EDIT_ATTEMPT = "Edit/Write/MultiEdit"
+    BASH_IMPLEMENTATION = "Bash for implementation"
+    FILE_CREATION = "Direct file creation"
+    TEST_EXECUTION = "Test execution"
+    DEPLOYMENT = "Deployment operation"
+    CODE_WRITING = "Code writing"
+
+
+@dataclass
+class Violation:
+    """Record of a delegation violation"""
+
+    violation_type: ViolationType
+    context: str
+    timestamp: float
+    severity_level: int
+
+
+class InstructionReinforcementHook:
+    """
+    Monitors PM messages for delegation violations and provides corrective feedback.
+
+    Circuit breaker pattern implementation to prevent PM from implementing
+    instead of delegating work to appropriate agents.
+    """
+
+    def __init__(self):
+        self.violation_count = 0
+        self.violations: List[Violation] = []
+
+        # Patterns that indicate PM is attempting forbidden actions
+        self.forbidden_patterns = [
+            # Direct implementation language - EXPANDED
+            (
+                r"I'll\s+(fix|create|write|implement|code|build|update|generate|modify|set\s+up|configure|optimize|rewrite|run|test|deploy|push|analyze|review|setup)",
+                ViolationType.CODE_WRITING,
+            ),
+            (
+                r"I'm\s+(fix|create|write|implement|code|build|update|generate|modify)",
+                ViolationType.CODE_WRITING,
+            ),
+            (
+                r"Let\s+me\s+(edit|write|modify|create|update|fix|run|execute|commit|refactor|configure|set\s+up|review)",
+                ViolationType.EDIT_ATTEMPT,
+            ),
+            (
+                r"I\s+will\s+(implement|code|build|create|write|update|fix)",
+                ViolationType.CODE_WRITING,
+            ),
+            (
+                r"I'm\s+(going\s+to|about\s+to)\s+(fix|create|write|implement|update|modify)",
+                ViolationType.CODE_WRITING,
+            ),
+            # Common honeypot phrases
+            (
+                r"Here's\s+(the|my|an?)\s+(implementation|code|SQL|query|solution|analysis|fix)",
+                ViolationType.CODE_WRITING,
+            ),
+            (
+                r"The\s+(query|code|implementation|solution)\s+(would\s+be|is)",
+                ViolationType.CODE_WRITING,
+            ),
+            (r"I\s+(found|identified)\s+(these\s+)?issues", ViolationType.CODE_WRITING),
+            # Deployment and setup patterns
+            (
+                r"Setting\s+up\s+(the\s+)?(authentication|containers|environment|docker)",
+                ViolationType.DEPLOYMENT,
+            ),
+            (r"Deploying\s+(to|the)", ViolationType.DEPLOYMENT),
+            (r"I'll\s+(deploy|push|host|launch)", ViolationType.DEPLOYMENT),
+            # Tool usage patterns - EXPANDED
+            (r"Using\s+(Edit|Write|MultiEdit)\s+tool", ViolationType.EDIT_ATTEMPT),
+            (r"<invoke\s+name=\"(Edit|Write|MultiEdit)\"", ViolationType.EDIT_ATTEMPT),
+            (
+                r"Running\s+(bash\s+command|git\s+commit|npm|yarn|python|node|go|tests|pytest)",
+                ViolationType.BASH_IMPLEMENTATION,
+            ),
+            (r"Executing\s+(tests|test\s+suite|pytest)", ViolationType.TEST_EXECUTION),
+            # Testing patterns - EXPANDED
+            (
+                r"(Testing|I'll\s+test|Let\s+me\s+test)\s+(the\s+)?(payment|API|endpoint)",
+                ViolationType.TEST_EXECUTION,
+            ),
+            (
+                r"I'll\s+(run|execute|verify)\s+(the\s+)?(tests|test\s+suite|endpoint)",
+                ViolationType.TEST_EXECUTION,
+            ),
+            (r"pytest|npm\s+test|yarn\s+test|go\s+test", ViolationType.TEST_EXECUTION),
+            # File operation patterns - EXPANDED
+            (
+                r"Creating\s+(new\s+|a\s+|the\s+)?(file|YAML|README|workflow)",
+                ViolationType.FILE_CREATION,
+            ),
+            (r"Writing\s+to\s+file", ViolationType.FILE_CREATION),
+            (
+                r"Updating\s+(the\s+)?(code|component|queries)",
+                ViolationType.CODE_WRITING,
+            ),
+            (
+                r"I'll\s+(update|modify)\s+(the\s+)?(component|code|React)",
+                ViolationType.CODE_WRITING,
+            ),
+        ]
+
+        # Patterns for correct delegation behavior - EXPANDED
+        self.delegation_patterns = [
+            r"delegat(e|ing)\s+(to|this)",
+            r"Task\s+tool",
+            r"(asking|request|have|use)\s+\w+\s+agent",
+            r"requesting\s+\w+\s+to",
+            r"will\s+(have|ask|request)\s+\w+\s+agent",
+            r"I'll\s+(have|ask|request|delegate)",
+            r"the\s+\w+\s+agent\s+(will|can|should)",
+        ]
+
+    def detect_violation_intent(
+        self, message: str
+    ) -> Optional[Tuple[ViolationType, str]]:
+        """
+        Check message for patterns indicating PM violation intent.
+
+        Args:
+            message: The PM's message to analyze
+
+        Returns:
+            Tuple of (ViolationType, matched_text) if violation detected, None otherwise
+        """
+        message_lower = message.lower()
+
+        # Check for forbidden patterns
+        for pattern, violation_type in self.forbidden_patterns:
+            match = re.search(pattern, message_lower, re.IGNORECASE)
+            if match:
+                # Check if this is actually a delegation (false positive check)
+                is_delegation = any(
+                    re.search(
+                        del_pattern,
+                        message_lower[max(0, match.start() - 50) : match.end() + 50],
+                    )
+                    for del_pattern in self.delegation_patterns
+                )
+
+                if not is_delegation:
+                    return (violation_type, match.group(0))
+
+        return None
+
+    def escalate_warning(self) -> str:
+        """
+        Generate escalating warning message based on violation count.
+
+        Returns:
+            Warning message with appropriate severity
+        """
+        if self.violation_count == 1:
+            return (
+                "⚠️ DELEGATION REMINDER: PM must delegate ALL implementation work.\n"
+                "Use the Task tool to delegate to the appropriate agent."
+            )
+        if self.violation_count == 2:
+            return (
+                "🚨 DELEGATION WARNING: Critical PM violation detected!\n"
+                "You MUST delegate implementation work. Do NOT use Edit/Write/Bash for implementation.\n"
+                "Next violation will result in session failure."
+            )
+        if self.violation_count == 3:
+            return (
+                "❌ CRITICAL DELEGATION FAILURE: Multiple PM violations detected.\n"
+                "PM has repeatedly attempted to implement instead of delegate.\n"
+                "Session integrity compromised. All work must be delegated to agents."
+            )
+        return (
+            f"❌❌❌ SEVERE VIOLATION (Count: {self.violation_count}): PM continues to violate delegation rules.\n"
+            "MANDATORY: Use Task tool to delegate ALL implementation to appropriate agents.\n"
+            "Current session may need to be terminated and restarted."
+        )
+
+    def check_message(self, message: str) -> Optional[Dict[str, any]]:
+        """
+        Check a PM message for violations and return feedback if needed.
+
+        Args:
+            message: The PM's message to check
+
+        Returns:
+            Dictionary with violation details and correction, or None if compliant
+        """
+        violation_result = self.detect_violation_intent(message)
+
+        if violation_result:
+            violation_type, context = violation_result
+            self.violation_count += 1
+
+            # Record the violation
+            import time
+
+            violation = Violation(
+                violation_type=violation_type,
+                context=context,
+                timestamp=time.time(),
+                severity_level=min(self.violation_count, 4),
+            )
+            self.violations.append(violation)
+
+            # Generate corrective feedback
+            warning = self.escalate_warning()
+
+            # Determine which agent should handle this
+            agent_mapping = {
+                ViolationType.EDIT_ATTEMPT: "Engineer",
+                ViolationType.CODE_WRITING: "Engineer",
+                ViolationType.BASH_IMPLEMENTATION: "Engineer or Ops",
+                ViolationType.FILE_CREATION: "Engineer or Documentation",
+                ViolationType.TEST_EXECUTION: "QA",
+                ViolationType.DEPLOYMENT: "Ops",
+            }
+
+            suggested_agent = agent_mapping.get(violation_type, "appropriate agent")
+
+            # Clean up context for task suggestion
+            clean_context = (
+                context.replace("I will ", "")
+                .replace("I'll ", "")
+                .replace("Let me ", "")
+            )
+
+            return {
+                "violation_detected": True,
+                "violation_count": self.violation_count,
+                "violation_type": violation_type.value,
+                "context": context,
+                "warning": warning,
+                "correction": f"MUST delegate to {suggested_agent} using Task tool",
+                "suggested_task": f"Task: Please {clean_context}",
+                "severity": min(self.violation_count, 4),
+            }
+
+        return None
+
+    def get_violation_summary(self) -> Dict[str, any]:
+        """
+        Get a summary of all violations in the session.
+
+        Returns:
+            Dictionary with violation statistics and details
+        """
+        if not self.violations:
+            return {
+                "total_violations": 0,
+                "status": "COMPLIANT",
+                "message": "No PM delegation violations detected",
+            }
+
+        violation_types = {}
+        for v in self.violations:
+            vtype = v.violation_type.value
+            violation_types[vtype] = violation_types.get(vtype, 0) + 1
+
+        status = "WARNING" if self.violation_count < 3 else "CRITICAL"
+
+        return {
+            "total_violations": self.violation_count,
+            "status": status,
+            "violation_types": violation_types,
+            "most_recent": self.violations[-1].context if self.violations else None,
+            "recommendation": (
+                "Review PM delegation training"
+                if self.violation_count > 2
+                else "Continue monitoring"
+            ),
+        }
+
+    def reset(self):
+        """Reset violation tracking for a new session"""
+        self.violation_count = 0
+        self.violations = []

claude_mpm/services/agents/deployment/deployment_wrapper.py

@@ -69,3 +69,62 @@ class DeploymentServiceWrapper:
             "errors": [],
             "target_dir": str(project_dir),
         }
+
+    def get_agent_details(self, agent_name: str) -> Dict[str, Any]:
+        """Get detailed information for a specific agent.
+
+        Args:
+            agent_name: Name of the agent
+
+        Returns:
+            Agent details dictionary or empty dict if not found
+        """
+        try:
+            # Try to get from list of available agents
+            available_agents = self.service.list_available_agents()
+            for agent in available_agents:
+                if agent.get("name") == agent_name:
+                    # Get template path for the agent
+                    templates_dir = self.service.templates_dir
+                    agent_path = templates_dir / f"{agent_name}.md"
+
+                    # Read agent content if file exists
+                    if agent_path.exists():
+                        with open(agent_path) as f:
+                            content = f.read()
+
+                        # Parse metadata from content
+                        import yaml
+
+                        metadata = {}
+                        if content.startswith("---"):
+                            # Extract frontmatter
+                            parts = content.split("---", 2)
+                            if len(parts) >= 2:
+                                try:
+                                    metadata = yaml.safe_load(parts[1])
+                                except yaml.YAMLError:
+                                    pass
+
+                        return {
+                            "name": agent_name,
+                            "path": str(agent_path),
+                            "type": agent.get("type", "agent"),
+                            "version": metadata.get("version", "1.0.0"),
+                            "description": metadata.get("description", ""),
+                            "specializations": metadata.get("specializations", []),
+                            "metadata": metadata,
+                            "content": content,
+                            "exists": True,
+                        }
+
+            # Agent not found in available agents
+            return {
+                "name": agent_name,
+                "exists": False,
+                "error": f"Agent '{agent_name}' not found",
+            }
+
+        except Exception as e:
+            # Return error information
+            return {"name": agent_name, "exists": False, "error": str(e)}

claude_mpm/services/agents/deployment/multi_source_deployment_service.py

@@ -199,9 +199,12 @@ class MultiSourceAgentDeploymentService:
                                     f"Project agent '{agent_name}' v{other_agent['version']} "
                                     f"overridden by higher system version v{highest_version_agent['version']}"
                                 )
-                            elif other_agent["source"] == "user" and highest_version_agent[
+                            elif other_agent[
                                 "source"
-                            ] in ["system", "project"]:
+                            ] == "user" and highest_version_agent["source"] in [
+                                "system",
+                                "project",
+                            ]:
                                 self.logger.warning(
                                     f"User agent '{agent_name}' v{other_agent['version']} "
                                     f"overridden by higher {highest_version_agent['source']} version v{highest_version_agent['version']}"

claude_mpm/utils/log_cleanup.py

@@ -9,7 +9,7 @@ import gzip
 import logging
 import os
 import shutil
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Dict, Optional, Tuple
 
@@ -92,7 +92,7 @@ class LogCleanupUtility:
             logger.info(f"Sessions directory not found: {sessions_dir}")
             return 0, 0.0
 
-        cutoff_time = datetime.now() - timedelta(days=max_age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=max_age_days)
         removed_count = 0
         total_size = 0.0
 
@@ -107,7 +107,7 @@ class LogCleanupUtility:
 
                 try:
                     # Check directory modification time
-                    mtime = datetime.fromtimestamp(session_dir.stat().st_mtime)
+                    mtime = datetime.fromtimestamp(session_dir.stat().st_mtime, tz=timezone.utc)
 
                     if mtime < cutoff_time:
                         # Calculate directory size
@@ -117,14 +117,14 @@ class LogCleanupUtility:
                         if dry_run:
                             logger.info(
                                 f"[DRY RUN] Would remove session: {session_dir.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {dir_size:.2f} MB)"
                             )
                         else:
                             shutil.rmtree(session_dir)
                             logger.info(
                                 f"Removed session: {session_dir.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {dir_size:.2f} MB)"
                             )
 
@@ -159,7 +159,7 @@ class LogCleanupUtility:
         Returns:
             Tuple of (files removed, space freed in MB)
         """
-        cutoff_time = datetime.now() - timedelta(days=max_age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=max_age_days)
         removed_count = 0
         total_size = 0.0
 
@@ -169,7 +169,7 @@ class LogCleanupUtility:
         for ext in LogCleanupConfig.ARCHIVE_EXTENSIONS:
             for archive_file in self.base_log_dir.rglob(f"*{ext}"):
                 try:
-                    mtime = datetime.fromtimestamp(archive_file.stat().st_mtime)
+                    mtime = datetime.fromtimestamp(archive_file.stat().st_mtime, tz=timezone.utc)
 
                     if mtime < cutoff_time:
                         file_size = archive_file.stat().st_size / (1024 * 1024)  # MB
@@ -178,14 +178,14 @@ class LogCleanupUtility:
                         if dry_run:
                             logger.info(
                                 f"[DRY RUN] Would remove archive: {archive_file.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {file_size:.2f} MB)"
                             )
                         else:
                             archive_file.unlink()
                             logger.info(
                                 f"Removed archive: {archive_file.name} "
-                                f"(age: {(datetime.now() - mtime).days} days, "
+                                f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                 f"size: {file_size:.2f} MB)"
                             )
 
@@ -218,7 +218,7 @@ class LogCleanupUtility:
         Returns:
             Tuple of (files removed, space freed in MB)
         """
-        cutoff_time = datetime.now() - timedelta(days=max_age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=max_age_days)
         removed_count = 0
         total_size = 0.0
 
@@ -238,7 +238,7 @@ class LogCleanupUtility:
 
                 for log_file in log_dir.glob(pattern):
                     try:
-                        mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+                        mtime = datetime.fromtimestamp(log_file.stat().st_mtime, tz=timezone.utc)
 
                         if mtime < cutoff_time:
                             file_size = log_file.stat().st_size / (1024 * 1024)  # MB
@@ -247,14 +247,14 @@ class LogCleanupUtility:
                             if dry_run:
                                 logger.info(
                                     f"[DRY RUN] Would remove log: {log_file.name} "
-                                    f"(age: {(datetime.now() - mtime).days} days, "
+                                    f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                     f"size: {file_size:.2f} MB)"
                                 )
                             else:
                                 log_file.unlink()
                                 logger.info(
                                     f"Removed log: {log_file.name} "
-                                    f"(age: {(datetime.now() - mtime).days} days, "
+                                    f"(age: {(datetime.now(timezone.utc) - mtime).days} days, "
                                     f"size: {file_size:.2f} MB)"
                                 )
 
@@ -321,7 +321,7 @@ class LogCleanupUtility:
         Returns:
             Tuple of (files compressed, space saved in MB)
         """
-        cutoff_time = datetime.now() - timedelta(days=age_days)
+        cutoff_time = datetime.now(timezone.utc) - timedelta(days=age_days)
         compressed_count = 0
         space_saved = 0.0
 
@@ -331,7 +331,7 @@ class LogCleanupUtility:
                 continue
 
             try:
-                mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
+                mtime = datetime.fromtimestamp(log_file.stat().st_mtime, tz=timezone.utc)
 
                 if mtime < cutoff_time:
                     original_size = log_file.stat().st_size / (1024 * 1024)  # MB
@@ -408,7 +408,7 @@ class LogCleanupUtility:
                 stats["oldest_session"] = {
                     "name": oldest.name,
                     "age_days": (
-                        datetime.now() - datetime.fromtimestamp(oldest.stat().st_mtime)
+                        datetime.now(timezone.utc) - datetime.fromtimestamp(oldest.stat().st_mtime, tz=timezone.utc)
                     ).days,
                 }
 
@@ -429,7 +429,7 @@ class LogCleanupUtility:
                 "name": oldest_log.name,
                 "path": str(oldest_log.relative_to(self.base_log_dir)),
                 "age_days": (
-                    datetime.now() - datetime.fromtimestamp(oldest_log.stat().st_mtime)
+                    datetime.now(timezone.utc) - datetime.fromtimestamp(oldest_log.stat().st_mtime, tz=timezone.utc)
                 ).days,
             }
 

claude_mpm/utils/subprocess_utils.py

@@ -83,7 +83,7 @@ def run_command(command_string: str, timeout: float = 60) -> str:
             returncode=getattr(e, "returncode", None),
             stdout=getattr(e, "stdout", ""),
             stderr=stderr,
-        )
+        ) from e
 
 
 def run_subprocess(
@@ -137,16 +137,16 @@ def run_subprocess(
             returncode=None,
             stdout=e.stdout.decode() if e.stdout else "",
             stderr=e.stderr.decode() if e.stderr else "",
-        )
+        ) from e
     except subprocess.CalledProcessError as e:
         raise SubprocessError(
             f"Command failed with return code {e.returncode}: {' '.join(cmd)}",
             returncode=e.returncode,
             stdout=e.stdout if e.stdout else "",
             stderr=e.stderr if e.stderr else "",
-        )
+        ) from e
     except Exception as e:
-        raise SubprocessError(f"Subprocess execution failed: {e}")
+        raise SubprocessError(f"Subprocess execution failed: {e}") from e
 
 
 async def run_subprocess_async(
@@ -195,7 +195,7 @@ async def run_subprocess_async(
             await process.wait()
             raise SubprocessError(
                 f"Command timed out after {timeout}s: {' '.join(cmd)}", returncode=None
-            )
+            ) from None
 
         return SubprocessResult(
             returncode=process.returncode,
@@ -205,7 +205,7 @@ async def run_subprocess_async(
 
     except Exception as e:
         if not isinstance(e, SubprocessError):
-            raise SubprocessError(f"Async subprocess execution failed: {e}")
+            raise SubprocessError(f"Async subprocess execution failed: {e}") from e
         raise