claude-mpm 3.4.10__py3-none-any.whl → 5.4.85__py3-none-any.whl

claude_mpm/services/utility_service.py

@@ -0,0 +1,280 @@
+from pathlib import Path
+
+"""Utility service for various helper functions.
+
+This service handles:
+1. Agent delegation detection
+2. Session event logging
+3. Text processing utilities
+4. Pattern matching utilities
+
+Extracted from ClaudeRunner to follow Single Responsibility Principle.
+"""
+
+import json
+import re
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional, Tuple
+
+from claude_mpm.core.base_service import BaseService
+from claude_mpm.services.core.interfaces import UtilityServiceInterface
+
+
+class UtilityService(BaseService, UtilityServiceInterface):
+    """Service for utility functions and helper methods."""
+
+    def __init__(self):
+        """Initialize the utility service."""
+        super().__init__(name="utility_service")
+
+    async def _initialize(self) -> None:
+        """Initialize the service. No special initialization needed."""
+
+    async def _cleanup(self) -> None:
+        """Cleanup service resources. No cleanup needed."""
+
+    def contains_delegation(self, text: str) -> bool:
+        """Check if text contains signs of agent delegation.
+
+        Args:
+            text: Text to check for delegation patterns
+
+        Returns:
+            bool: True if delegation patterns are found
+        """
+        # Look for common delegation patterns
+        delegation_patterns = [
+            "Task(",
+            "subagent_type=",
+            "delegating to",
+            "asking the",
+            "engineer agent",
+            "qa agent",
+            "documentation agent",
+            "research agent",
+            "security agent",
+            "ops agent",
+            "version_control agent",
+            "data_engineer agent",
+        ]
+
+        text_lower = text.lower()
+        return any(pattern.lower() in text_lower for pattern in delegation_patterns)
+
+    def extract_agent_from_response(self, text: str) -> Optional[str]:
+        """Try to extract agent name from delegation response.
+
+        Args:
+            text: Response text to extract agent name from
+
+        Returns:
+            Optional[str]: Extracted agent name or None if not found
+        """
+        # Pattern 1: subagent_type="agent_name"
+        match = re.search(r'subagent_type=["\']([^"\']*)["\'\)]', text)
+        if match:
+            return match.group(1)
+
+        # Pattern 2: "engineer agent" etc
+        agent_names = [
+            "engineer",
+            "qa",
+            "documentation",
+            "research",
+            "security",
+            "ops",
+            "version_control",
+            "data_engineer",
+        ]
+        text_lower = text.lower()
+        for agent in agent_names:
+            if f"{agent} agent" in text_lower or f"agent: {agent}" in text_lower:
+                return agent
+
+        return None
+
+    def log_session_event(self, log_file: Optional[Path], event_data: Dict[str, Any]):
+        """Log an event to the session log file.
+
+        Args:
+            log_file: Path to the session log file
+            event_data: Event data to log
+        """
+        if not log_file:
+            return
+
+        try:
+            log_entry = {
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                **event_data,
+            }
+
+            with log_file.open("a") as f:
+                f.write(json.dumps(log_entry) + "\n")
+
+        except OSError as e:
+            self.logger.debug(f"IO error logging session event: {e}")
+        except Exception as e:
+            self.logger.debug(f"Failed to log session event: {e}")
+
+    def validate_prompt(self, prompt: str) -> bool:
+        """Validate that a prompt is not empty and properly formatted.
+
+        Args:
+            prompt: Prompt to validate
+
+        Returns:
+            bool: True if prompt is valid
+        """
+        if not prompt or not prompt.strip():
+            return False
+
+        # Check for minimum length
+        return not len(prompt.strip()) < 3
+
+    def sanitize_filename(self, filename: str) -> str:
+        """Sanitize a filename by removing invalid characters.
+
+        Args:
+            filename: Filename to sanitize
+
+        Returns:
+            str: Sanitized filename
+        """
+        # Remove invalid characters for filenames
+        invalid_chars = '<>:"/\\|?*'
+        sanitized = filename
+        for char in invalid_chars:
+            sanitized = sanitized.replace(char, "_")
+
+        # Remove leading/trailing whitespace and dots
+        sanitized = sanitized.strip(" .")
+
+        # Ensure filename is not empty
+        if not sanitized:
+            sanitized = "untitled"
+
+        return sanitized
+
+    def format_error_message(self, error: Exception, context: str = "") -> str:
+        """Format an error message with context.
+
+        Args:
+            error: Exception to format
+            context: Optional context information
+
+        Returns:
+            str: Formatted error message
+        """
+        error_type = type(error).__name__
+        error_msg = str(error)
+
+        if context:
+            return f"{context}: {error_type}: {error_msg}"
+        return f"{error_type}: {error_msg}"
+
+    def truncate_text(
+        self, text: str, max_length: int = 100, suffix: str = "..."
+    ) -> str:
+        """Truncate text to a maximum length.
+
+        Args:
+            text: Text to truncate
+            max_length: Maximum length before truncation
+            suffix: Suffix to add when truncating
+
+        Returns:
+            str: Truncated text
+        """
+        if len(text) <= max_length:
+            return text
+
+        return text[: max_length - len(suffix)] + suffix
+
+    def parse_key_value_pairs(self, text: str) -> Dict[str, str]:
+        """Parse key=value pairs from text.
+
+        Args:
+            text: Text containing key=value pairs
+
+        Returns:
+            Dict[str, str]: Parsed key-value pairs
+        """
+        pairs = {}
+
+        # Look for key=value patterns
+        pattern = r'(\w+)=(["\']?)([^"\'\s]*)\2'
+        matches = re.findall(pattern, text)
+
+        for key, _quote, value in matches:
+            pairs[key] = value
+
+        return pairs
+
+    def get_service_status(self) -> Dict[str, Any]:
+        """Get current utility service status.
+
+        Returns:
+            Dict[str, Any]: Service status information
+        """
+        return {
+            "service_available": True,
+            "delegation_detection": True,
+            "session_logging": True,
+            "text_processing": True,
+            "pattern_matching": True,
+        }
+
+    # Implementation of abstract methods from UtilityServiceInterface
+
+    def format_file_size(self, size_bytes: int) -> str:
+        """Format file size in human-readable format."""
+        if size_bytes == 0:
+            return "0 B"
+        units = ["B", "KB", "MB", "GB", "TB"]
+        unit_index = 0
+        size = float(size_bytes)
+        while size >= 1024 and unit_index < len(units) - 1:
+            size /= 1024
+            unit_index += 1
+        return (
+            f"{size:.1f} {units[unit_index]}"
+            if unit_index > 0
+            else f"{int(size)} {units[unit_index]}"
+        )
+
+    def format_duration(self, seconds: float) -> str:
+        """Format duration in human-readable format."""
+        if seconds < 60:
+            return f"{seconds:.1f}s"
+        minutes = int(seconds // 60)
+        remaining_seconds = int(seconds % 60)
+        if minutes < 60:
+            return (
+                f"{minutes}m {remaining_seconds}s"
+                if remaining_seconds > 0
+                else f"{minutes}m"
+            )
+        hours = int(minutes // 60)
+        remaining_minutes = int(minutes % 60)
+        return (
+            f"{hours}h {remaining_minutes}m" if remaining_minutes > 0 else f"{hours}h"
+        )
+
+    def generate_unique_id(self, prefix: str = "") -> str:
+        """Generate a unique identifier."""
+        unique_id = str(uuid.uuid4())
+        return f"{prefix}_{unique_id}" if prefix else unique_id
+
+    def validate_path(self, path: Path) -> Tuple[bool, Optional[str]]:
+        """Validate a filesystem path."""
+        try:
+            if not isinstance(path, Path):
+                return False, "Path must be a Path object"
+            path_str = str(path)
+            if not path_str or path_str.isspace():
+                return False, "Path cannot be empty"
+            return True, None
+        except Exception as e:
+            return False, f"Path validation error: {e!s}"

claude_mpm/services/version_control/__init__.py

@@ -8,63 +8,60 @@ This package provides modular services for the Version Control Agent including:
 - Conflict resolution
 """
 
-from .git_operations import (
-    GitOperationsManager,
-    GitBranchInfo,
-    GitOperationResult,
-    GitOperationError,
-)
-
-from .semantic_versioning import (
-    SemanticVersionManager,
-    SemanticVersion,
-    VersionBumpType,
-    VersionMetadata,
-    ChangeAnalysis,
-)
-
 from .branch_strategy import (
+    BranchLifecycleRule,
+    BranchNamingRule,
     BranchStrategyManager,
     BranchStrategyType,
     BranchType,
     BranchWorkflow,
-    BranchNamingRule,
-    BranchLifecycleRule,
 )
-
 from .conflict_resolution import (
+    ConflictAnalysis,
+    ConflictResolution,
     ConflictResolutionManager,
     ConflictType,
-    ResolutionStrategy,
     FileConflict,
-    ConflictResolution,
-    ConflictAnalysis,
+    ResolutionStrategy,
+)
+from .git_operations import (
+    GitBranchInfo,
+    GitOperationError,
+    GitOperationResult,
+    GitOperationsManager,
+)
+from .semantic_versioning import (
+    ChangeAnalysis,
+    SemanticVersion,
+    SemanticVersionManager,
+    VersionBumpType,
+    VersionMetadata,
 )
 
 __all__ = [
-    # Git Operations
-    "GitOperationsManager",
-    "GitBranchInfo",
-    "GitOperationResult",
-    "GitOperationError",
-    # Semantic Versioning
-    "SemanticVersionManager",
-    "SemanticVersion",
-    "VersionBumpType",
-    "VersionMetadata",
-    "ChangeAnalysis",
+    "BranchLifecycleRule",
+    "BranchNamingRule",
     # Branch Strategy
     "BranchStrategyManager",
     "BranchStrategyType",
     "BranchType",
     "BranchWorkflow",
-    "BranchNamingRule",
-    "BranchLifecycleRule",
+    "ChangeAnalysis",
+    "ConflictAnalysis",
+    "ConflictResolution",
     # Conflict Resolution
     "ConflictResolutionManager",
     "ConflictType",
-    "ResolutionStrategy",
     "FileConflict",
-    "ConflictResolution",
-    "ConflictAnalysis",
+    "GitBranchInfo",
+    "GitOperationError",
+    "GitOperationResult",
+    # Git Operations
+    "GitOperationsManager",
+    "ResolutionStrategy",
+    "SemanticVersion",
+    # Semantic Versioning
+    "SemanticVersionManager",
+    "VersionBumpType",
+    "VersionMetadata",
 ]

claude_mpm/services/version_control/branch_strategy.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Branch Strategy Manager - Branch strategy implementations for Version Control Agent.
 
@@ -9,13 +11,14 @@ This module provides comprehensive branch strategy management including:
 5. Branch lifecycle management
 """
 
-from enum import Enum
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple
-from dataclasses import dataclass, field
 import logging
 import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
+
+from claude_mpm.core.unified_paths import get_path_manager
 
 
 class BranchStrategyType(Enum):
@@ -264,7 +267,11 @@ class BranchStrategyManager:
             development_branch="develop",
             naming_rules=naming_rules,
             lifecycle_rules=lifecycle_rules,
-            merge_targets={"feature/*": "develop", "release/*": "main", "hotfix/*": "main"},
+            merge_targets={
+                "feature/*": "develop",
+                "release/*": "main",
+                "hotfix/*": "main",
+            },
             quality_gates=["testing", "code_review"],
         )
 
@@ -303,7 +310,7 @@ class BranchStrategyManager:
         """Load strategy configuration from project files."""
         # Try to load from configuration files
         config_files = [
-            ".claude-pm/config.json",
+            f"{get_path_manager().CONFIG_DIR}/config.json",
             "workflow.md",
             ".github/workflows/branch-strategy.yml",
             "branch-strategy.json",
@@ -351,9 +358,8 @@ class BranchStrategyManager:
             self.current_strategy = self.strategies[strategy_type]
             self.logger.info(f"Set branch strategy to {strategy_type.value}")
             return True
-        else:
-            self.logger.error(f"Unknown strategy type: {strategy_type}")
-            return False
+        self.logger.error(f"Unknown strategy type: {strategy_type}")
+        return False
 
     def generate_branch_name(
         self,
@@ -388,10 +394,9 @@ class BranchStrategyManager:
             prefix = branch_type.value + "/"
             if ticket_id:
                 return f"{prefix}{ticket_id}"
-            elif description:
+            if description:
                 return f"{prefix}{self._sanitize_branch_name(description)}"
-            else:
-                return f"{prefix}{datetime.now().strftime('%Y%m%d')}"
+            return f"{prefix}{datetime.now(timezone.utc).strftime('%Y%m%d')}"
 
         # Generate name based on rule
         if strategy.strategy_type == BranchStrategyType.ISSUE_DRIVEN:
@@ -437,7 +442,10 @@ class BranchStrategyManager:
 
                 # Check length
                 if rule.max_length and len(branch_name) > rule.max_length:
-                    return False, f"Branch name exceeds maximum length: {rule.max_length}"
+                    return (
+                        False,
+                        f"Branch name exceeds maximum length: {rule.max_length}",
+                    )
 
                 return True, "Valid branch name"
 
@@ -604,15 +612,16 @@ class BranchStrategyManager:
         # Default merge message
         if ticket_title:
             return f"Merge {branch_name}: {ticket_title}"
-        else:
-            return f"Merge {branch_name}"
+        return f"Merge {branch_name}"
 
     def get_quality_gates(self) -> List[str]:
         """Get quality gates for the current strategy."""
         strategy = self.get_current_strategy()
         return strategy.quality_gates
 
-    def create_custom_strategy(self, name: str, config: Dict[str, Any]) -> BranchWorkflow:
+    def create_custom_strategy(
+        self, name: str, config: Dict[str, Any]
+    ) -> BranchWorkflow:
         """
         Create a custom branch strategy.
 

claude_mpm/services/version_control/conflict_resolution.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """
 Conflict Resolution Manager - Basic conflict resolution for Version Control Agent.
 
@@ -9,14 +11,11 @@ This module provides conflict resolution management including:
 5. Resolution validation
 """
 
+import logging
 import re
-import difflib
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple, Union
 from dataclasses import dataclass, field
 from enum import Enum
-import logging
+from typing import Any, Dict, List, Optional
 
 
 class ConflictType(Enum):
@@ -114,7 +113,11 @@ class ConflictResolutionManager:
         self.logger = logger
 
         # Conflict markers
-        self.conflict_markers = {"start": r"^<{7} ", "separator": r"^={7}$", "end": r"^>{7} "}
+        self.conflict_markers = {
+            "start": r"^<{7} ",
+            "separator": r"^={7}$",
+            "end": r"^>{7} ",
+        }
 
         # Auto-resolution patterns
         self.auto_resolution_patterns = {
@@ -125,7 +128,14 @@ class ConflictResolutionManager:
         }
 
         # File types that can be auto-resolved
-        self.auto_resolvable_extensions = {".md", ".txt", ".json", ".yml", ".yaml", ".xml"}
+        self.auto_resolvable_extensions = {
+            ".md",
+            ".txt",
+            ".json",
+            ".yml",
+            ".yaml",
+            ".xml",
+        }
 
         # Binary file extensions
         self.binary_extensions = {
@@ -236,9 +246,7 @@ class ConflictResolutionManager:
 
             conflicted_files = []
             for line in result.stdout.strip().split("\n"):
-                if line.strip() and (
-                    line.startswith("UU") or line.startswith("AA") or line.startswith("DD")
-                ):
+                if line.strip() and (line.startswith(("UU", "AA", "DD"))):
                     # Extract filename
                     filename = line[3:].strip()
                     conflicted_files.append(filename)
@@ -266,7 +274,9 @@ class ConflictResolutionManager:
             )
 
         try:
-            with open(full_path, "r", encoding="utf-8") as f:
+            with Path(full_path).open(
+                encoding="utf-8",
+            ) as f:
                 content = f.read()
 
             # Parse conflict markers
@@ -313,7 +323,7 @@ class ConflictResolutionManager:
 
         # Check content (simple heuristic)
         try:
-            with open(file_path, "rb") as f:
+            with file_path.open("rb") as f:
                 chunk = f.read(1024)
                 if b"\0" in chunk:
                     return True
@@ -379,7 +389,9 @@ class ConflictResolutionManager:
         # For now, default to content conflict
         return ConflictType.CONTENT
 
-    def _is_auto_resolvable(self, file_path: str, markers: List[ConflictMarker]) -> bool:
+    def _is_auto_resolvable(
+        self, file_path: str, markers: List[ConflictMarker]
+    ) -> bool:
         """Determine if conflict can be automatically resolved."""
         file_ext = Path(file_path).suffix.lower()
 
@@ -388,11 +400,7 @@ class ConflictResolutionManager:
             return False
 
         # Check if all conflicts are simple
-        for marker in markers:
-            if not self._is_simple_conflict(marker):
-                return False
-
-        return True
+        return all(self._is_simple_conflict(marker) for marker in markers)
 
     def _is_simple_conflict(self, marker: ConflictMarker) -> bool:
         """Check if a conflict marker represents a simple conflict."""
@@ -412,10 +420,7 @@ class ConflictResolutionManager:
             return True
 
         # Check if differences are only imports
-        if self._only_import_differences(ours_lines, theirs_lines):
-            return True
-
-        return False
+        return bool(self._only_import_differences(ours_lines, theirs_lines))
 
     def _only_whitespace_differences(self, ours: List[str], theirs: List[str]) -> bool:
         """Check if differences are only whitespace."""
@@ -428,7 +433,7 @@ class ConflictResolutionManager:
         # This is a simplified check
         for line in ours + theirs:
             stripped = line.strip()
-            if stripped and not (stripped.startswith("#") or stripped.startswith("//")):
+            if stripped and not (stripped.startswith(("#", "//"))):
                 return False
         return True
 
@@ -442,7 +447,9 @@ class ConflictResolutionManager:
                 return False
         return True
 
-    def _generate_resolution_suggestion(self, file_path: str, markers: List[ConflictMarker]) -> str:
+    def _generate_resolution_suggestion(
+        self, file_path: str, markers: List[ConflictMarker]
+    ) -> str:
         """Generate resolution suggestion for a file."""
         if not markers:
             return "No conflict markers found"
@@ -451,15 +458,19 @@ class ConflictResolutionManager:
 
         for i, marker in enumerate(markers):
             if not marker.ours_content and marker.theirs_content:
-                suggestions.append(f"Conflict {i+1}: Accept incoming changes (theirs)")
+                suggestions.append(
+                    f"Conflict {i + 1}: Accept incoming changes (theirs)"
+                )
             elif marker.ours_content and not marker.theirs_content:
-                suggestions.append(f"Conflict {i+1}: Keep current changes (ours)")
-            elif self._only_whitespace_differences(marker.ours_content, marker.theirs_content):
+                suggestions.append(f"Conflict {i + 1}: Keep current changes (ours)")
+            elif self._only_whitespace_differences(
+                marker.ours_content, marker.theirs_content
+            ):
                 suggestions.append(
-                    f"Conflict {i+1}: Whitespace differences only - can auto-resolve"
+                    f"Conflict {i + 1}: Whitespace differences only - can auto-resolve"
                 )
             else:
-                suggestions.append(f"Conflict {i+1}: Manual merge required")
+                suggestions.append(f"Conflict {i + 1}: Manual merge required")
 
         return "; ".join(suggestions)
 
@@ -496,10 +507,9 @@ class ConflictResolutionManager:
 
         if auto_ratio > 0.8:
             return "simple"
-        elif auto_ratio > 0.5:
+        if auto_ratio > 0.5:
             return "moderate"
-        else:
-            return "complex"
+        return "complex"
 
     def _estimate_resolution_time(self, file_conflicts: List[FileConflict]) -> int:
         """Estimate resolution time in minutes."""
@@ -555,7 +565,9 @@ class ConflictResolutionManager:
                 resolutions.append(resolution)
 
             except Exception as e:
-                self.logger.error(f"Error resolving conflict in {conflict.file_path}: {e}")
+                self.logger.error(
+                    f"Error resolving conflict in {conflict.file_path}: {e}"
+                )
                 resolutions.append(
                     ConflictResolution(
                         file_path=conflict.file_path,
@@ -579,14 +591,18 @@ class ConflictResolutionManager:
 
         try:
             # Read current content
-            with open(file_path, "r", encoding="utf-8") as f:
+            with Path(file_path).open(
+                encoding="utf-8",
+            ) as f:
                 content = f.read()
 
             # Apply resolution strategy
-            resolved_content = self._apply_resolution_strategy(content, conflict.markers, strategy)
+            resolved_content = self._apply_resolution_strategy(
+                content, conflict.markers, strategy
+            )
 
             # Write resolved content
-            with open(file_path, "w", encoding="utf-8") as f:
+            with file_path.open("w", encoding="utf-8") as f:
                 f.write(resolved_content)
 
             return ConflictResolution(