claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/utility_service.py

@@ -0,0 +1,285 @@
+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
+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."""
+        pass
+
+    async def _cleanup(self) -> None:
+        """Cleanup service resources. No cleanup needed."""
+        pass
+
+    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().isoformat(), **event_data}
+
+            with open(log_file, "a") as f:
+                f.write(json.dumps(log_entry) + "\n")
+
+        except (OSError, IOError) 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
+        if len(prompt.strip()) < 3:
+            return False
+
+        return True
+
+    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}"
+        else:
+            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: {str(e)}"
+
+

claude_mpm/services/version_control/__init__.py

@@ -8,37 +8,34 @@ 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__ = [

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,15 +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
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple
 
-from claude_mpm.core.config_paths import ConfigPaths
+from claude_mpm.core.unified_paths import get_path_manager
 
 
 class BranchStrategyType(Enum):
@@ -266,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"],
         )
 
@@ -305,7 +310,7 @@ class BranchStrategyManager:
         """Load strategy configuration from project files."""
         # Try to load from configuration files
         config_files = [
-            f"{ConfigPaths.CONFIG_DIR}/config.json",
+            f"{get_path_manager().CONFIG_DIR}/config.json",
             "workflow.md",
             ".github/workflows/branch-strategy.yml",
             "branch-strategy.json",
@@ -439,7 +444,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"
 
@@ -614,7 +622,9 @@ class BranchStrategyManager:
         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,13 @@ This module provides conflict resolution management including:
 5. Resolution validation
 """
 
-import re
 import difflib
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple, Union
+import logging
+import re
 from dataclasses import dataclass, field
+from datetime import datetime
 from enum import Enum
-import logging
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 
 class ConflictType(Enum):
@@ -114,7 +115,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 +130,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 = {
@@ -237,7 +249,9 @@ 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")
+                    line.startswith("UU")
+                    or line.startswith("AA")
+                    or line.startswith("DD")
                 ):
                     # Extract filename
                     filename = line[3:].strip()
@@ -379,7 +393,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()
 
@@ -442,7 +458,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"
@@ -454,7 +472,9 @@ class ConflictResolutionManager:
                 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):
+            elif self._only_whitespace_differences(
+                marker.ours_content, marker.theirs_content
+            ):
                 suggestions.append(
                     f"Conflict {i+1}: Whitespace differences only - can auto-resolve"
                 )
@@ -555,7 +575,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,
@@ -583,7 +605,9 @@ class ConflictResolutionManager:
                 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: